redstruct 0.1.0

data/lib/redstruct/types/list.rb

@@ -0,0 +1,78 @@
+module Redstruct
+  module Types
+    class List < Redstruct::Types::Struct
+      include Redstruct::Utils::Scriptable
+
+      def clear
+        delete
+      end
+
+      def empty?
+        return !exists?
+      end
+
+      def [](index)
+        return self.connection.lindex(@key, index.to_i)
+      end
+
+      def []=(index, value)
+        return self.connection.lset(@key, index.to_i, value)
+      end
+
+      def append(*elements, max: 0)
+        max = max.to_i
+        return self.connection.rpush(@key, elements) if max <= 0
+        return push_and_trim_script(keys: @key, argv: [max - 1, 0] + elements)
+      end
+
+      def prepend(*elements, max: nil)
+        max = max.to_i
+        return self.connection.lpush(@key, elements) if max <= 0
+        return push_and_trim_script(keys: @key, argv: [max - 1, 1] + elements)
+      end
+
+      def pop(timeout: nil)
+        options = {}
+        options[:timeout] = timeout.to_i unless timeout.nil?
+        return self.connection.blpop(@key, options)&.last
+      end
+
+      def remove(value, count: 1)
+        count = [1, count.to_i].max
+        self.connection.lrem(@key, count, value)
+      end
+
+      def size
+        return self.connection.llen(@key)
+      end
+
+      def slice(start = 0, length = -1)
+        return self.connection.lrange(@key, start.to_i, length.to_i)
+      end
+
+      def to_a
+        return slice(0, -1)
+      end
+
+      # Appends or prepends (argv[1]) a number of items (argv[2]) to a list (keys[1]),
+      # then trims it out to size (argv[3])
+      # @param [Array<(::String)>] keys First key should be the key to the list to prepend to and resize
+      # @param [Array<(Fixnum, Fixnum, Array<::String>)>] argv The maximum size of the list; if 1, will lpush, otherwise rpush; the list of items to prepend
+      # @return [Fixnum] The length of the list after the operation
+      defscript :push_and_trim_script, <<~LUA
+        local max = tonumber(table.remove(ARGV, 1))
+        local prepend = tonumber(table.remove(ARGV, 1)) == 1
+        local push = prepend and 'lpush' or 'rpush'
+
+        local size = redis.call(push, KEYS[1], unpack(ARGV))
+        if size > max then
+          redis.call('ltrim', KEYS[1], 0, max)
+          size = max + 1
+        end
+
+        return size
+      LUA
+      protected :push_and_trim_script
+    end
+  end
+end

data/lib/redstruct/types/script.rb

@@ -0,0 +1,56 @@
+require 'digest'
+
+module Redstruct
+  module Types
+    # It is recommended you flush your script cache on the redis server every once in a while
+    class Script < Redstruct::Types::Base
+      ERROR_MESSAGE_PREFIX = 'NOSCRIPT'.freeze
+
+      # @return [::String] The Lua script to evaluate
+      attr_reader :script
+
+      def initialize(script:, **options)
+        script = script&.strip
+        raise(Redstruct::Error, 'No source script given') if script.empty?
+
+        super(**options)
+        self.script = script
+      end
+
+      def script=(script)
+        @sha1 = nil
+        @script = script.dup.freeze
+      end
+
+      def sha1
+        return @sha1 ||= begin
+          Digest::SHA1.hexdigest(@script)
+        end
+      end
+
+      def exists?
+        return self.connection.script(:exists, self.sha1)
+      end
+
+      def load
+        @sha1 = self.connection.script(:load, @script)
+        return @sha1
+      end
+
+      def eval(keys:, argv:)
+        keys = [keys] unless keys.is_a?(Array)
+        argv = [argv] unless argv.is_a?(Array)
+        self.connection.evalsha(self.sha1, keys, argv)
+      rescue Redis::CommandError => err
+        raise unless err.message.start_with?(ERROR_MESSAGE_PREFIX)
+        self.connection.eval(@script, keys, argv)
+      end
+
+      # :nocov:
+      def inspectable_attributes
+        return super.merge(sha1: self.sha1, script: @script.slice(0, 20))
+      end
+      # :nocov:
+    end
+  end
+end

data/lib/redstruct/types/set.rb

@@ -0,0 +1,96 @@
+module Redstruct
+  module Types
+    # Note: keep in mind Redis converts everything to a string on the DB side
+    class Set < Redstruct::Types::Struct
+      def clear
+        delete
+      end
+
+      def random(count: 1)
+        return self.connection.srandmember(@key, count.to_i)
+      end
+
+      def empty?
+        return !exists?
+      end
+
+      def contain?(member)
+        return self.connection.sismember(@key, member)
+      end
+      alias_method :include?, :contain?
+
+      def to_a
+        return self.connection.smembers(@key)
+      end
+
+      def add(*members)
+        return self.connection.sadd(@key, members)
+      end
+      alias_method :<<, :add
+
+      def size
+        return self.connection.scard(@key).to_i
+      end
+
+      def -(other)
+        return ::Set.new(self.connection.sdiff(@key, other.key))
+      end
+
+      def +(other)
+        return ::Set.new(self.connection.sunion(@key, other.key))
+      end
+
+      def |(other)
+        return ::Set.new(self.connection.sinter(@key, other.key))
+      end
+
+      def difference(other, dest: nil)
+        destination = coerce_destination(dest)
+        return self - other if destination.nil?
+
+        self.connection.sdiffstore(destination.key, @key, other.key)
+        return destination
+      end
+
+      def intersection(other, dest: nil)
+        destination = coerce_destination(dest)
+        return self - other if destination.nil?
+
+        self.connection.sinterstore(destination.key, @key, other.key)
+        return destination
+      end
+
+      def union(other, dest: nil)
+        destination = coerce_destination(dest)
+        return self - other if destination.nil?
+
+        self.connection.sunionstore(destination.key, @key, other.key)
+        return destination
+      end
+
+      def pop(count: 1)
+        return self.connection.spop(@key, count.to_i)
+      end
+
+      def remove(*members)
+        return self.connection.srem(@key, *members)
+      end
+
+      def each(options = {}, &block)
+        return self.connection.sscan_each(@key, options, &block)
+      end
+
+      def coerce_destination(dest)
+        return case dest
+        when ::String
+          @factory.set(dest)
+        when self.class
+          dest
+        else
+          nil
+        end
+      end
+      private :coerce_destination
+    end
+  end
+end

data/lib/redstruct/types/sorted_set.rb

@@ -0,0 +1,15 @@
+module Redstruct
+  module Types
+    class SortedSet < Redstruct::Types::Struct
+      DEFAULT_SCORE = 1.0
+
+      def add(options = {}, *items)
+        defaults = { nx: false, xx: false, ch: false }
+      end
+
+      def <<(item)
+        return self.connection.zadd(@key, DEFAULT_SCORE, item)
+      end
+    end
+  end
+end

data/lib/redstruct/types/string.rb

@@ -0,0 +1,64 @@
+module Redstruct
+  module Types
+    class String < Redstruct::Types::Struct
+      include Redstruct::Utils::Scriptable, Redstruct::Utils::Coercion
+
+      # @return [::String] The string value stored in the database
+      def get
+        return self.connection.get(@key)
+      end
+
+      # @param [Object] value The object to store; note, it will be stored using a string representation
+      # @param [Integer] expiry The expiry time in seconds; if nil, will never expire
+      # @param [Boolean] nx Not Exists: if true, will not set the key if it already existed
+      # @param [Boolean] xx Already Exists: if true, will set the key only if it already existed
+      # @return [Boolean] True if set, false otherwise
+      def set(value, expiry: nil, nx: nil, xx: nil)
+        options = {}
+        options[:ex] = expiry.to_i unless expiry.nil?
+        options[:nx] = nx unless nx.nil?
+        options[:xx] = xx unless xx.nil?
+
+        self.connection.set(@key, value, options) == 'OK'
+      end
+
+      # @param [::String] value The value to compare with
+      # @return [Boolean] True if deleted, false otherwise
+      def delete_if_equals(value)
+        coerce_bool(delete_if_equals_script(keys: @key, argv: value))
+      end
+
+      # @param [Object] value The object to store; note, it will be stored using a string representation
+      # @return [::String] The old value before setting it
+      def getset(value)
+        self.connection.getset(@key, value)
+      end
+
+      # @return [Fixnum] The length of the string
+      def length
+        self.connection.strlen(@key)
+      end
+
+      # @param [Fixnum] start Starting index of the slice
+      # @param [Fixnum] length Length of the slice; negative numbers start counting from the right (-1 = end)
+      # @return [Array<::String>] The requested slice from <start> with length <length>
+      def slice(start = 0, length = -1)
+        length = start + length if length >= 0
+        return self.connection.getrange(@key, start, length)
+      end
+
+      # Deletes the key (keys[1]) iff the value is equal to argv[1].
+      # @param [Array<(::String)>] keys The key to delete
+      # @param [Array<(::String)>] argv The value to compare with
+      # @return [Fixnum] 1 if deleted, 0 otherwise
+      defscript :delete_if_equals_script, <<~LUA
+        local deleted = false
+        if redis.call("get", KEYS[1]) == ARGV[1] then
+          deleted = redis.call("del", KEYS[1])
+        end
+
+        return deleted
+      LUA
+    end
+  end
+end

data/lib/redstruct/types/struct.rb

@@ -0,0 +1,41 @@
+require 'forwardable'
+
+module Redstruct
+  module Types
+    class Struct < Redstruct::Types::Base
+      include Redstruct::Utils::Inspectable
+
+      # @return [Boolean] Returns true if it exists in redis, false otherwise
+      def exists?
+        return self.connection.exists(@key)
+      end
+
+      # @return [Fixnum] 0 if nothing was deleted in the DB, 1 if it was
+      def delete
+        self.connection.del(@key)
+      end
+
+      def expire(ttl)
+        self.connection.expire(@key, ttl)
+      end
+
+      def expire_at(time)
+        self.connection.expire_at(@key,  time.to_i)
+      end
+
+      def persist
+        self.connection.persist(@key)
+      end
+
+      def type
+        self.connection.type(@key)
+      end
+
+      # :nocov:
+      def inspectable_attributes
+        super.merge(key: @key)
+      end
+      # :nocov:
+    end
+  end
+end

data/lib/redstruct/utils/coercion.rb

@@ -0,0 +1,33 @@
+module Redstruct
+  module Utils
+    # Coercion utilities to map Redis replies to Ruby types, or vice-versa
+    module Coercion
+      # Coerces the value into an array.
+      #   Returns the value if it is already an array (or subclass)
+      #   Returns value.to_a if it responds to to_a
+      #   Returns [value] otherwise
+      # @param [Object] value The value to coerce
+      # @return [Array] The coerced value
+      def coerce_array(value)
+        return [] if value.nil?
+        return value if value.is_a?(Array)
+        return value.to_a if value.respond_to?(:to_a)
+        return [value]
+      end
+      module_function :coerce_array
+
+      # Coerces an object into a boolean:
+      #   If nil or 0 (after .to_i) => false
+      #   True otherwise
+      # @param [Object] value The object to coerce into a bool
+      # @return [Boolean] Coerced value
+      def coerce_bool(value)
+        return false if value.nil?
+        return false if value.to_i == 0
+
+        return true
+      end
+      module_function :coerce_bool
+    end
+  end
+end

data/lib/redstruct/utils/inspectable.rb

@@ -0,0 +1,21 @@
+module Redstruct
+  module Utils
+    module Inspectable
+      def inspect
+        attributes = inspectable_attributes.map do |key, value|
+          "#{key}: <#{value.inspect}>"
+        end
+
+        return "#{self.class.name}: #{attributes.join(', ')}"
+      end
+
+      def inspectable_attributes
+        {}
+      end
+
+      def to_s
+        return inspect
+      end
+    end
+  end
+end

data/lib/redstruct/utils/scriptable.rb

@@ -0,0 +1,21 @@
+module Redstruct
+  module Utils
+    module Scriptable
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        def defscript(id, source)
+          constant = "SCRIPT_SOURCE_#{id.upcase}"
+          class_eval <<~METHOD, __FILE__, __LINE__ + 1
+          #{constant} = { id: '#{id}'.freeze, source: %(#{source}).freeze }.freeze
+            def #{id}(keys: [], argv: [])
+              return @factory.script(#{constant}[:id], #{constant}[:source]).eval(keys: keys, argv: argv)
+            end
+          METHOD
+        end
+      end
+    end
+  end
+end

data/lib/redstruct/version.rb

@@ -0,0 +1,3 @@
+module Redstruct
+  VERSION = '0.1.0'.freeze
+end

data/lib/redstruct/yard/defscript_handler.rb

@@ -0,0 +1,32 @@
+module Redstruct
+  class DefscriptHandler < YARD::Handlers::Ruby::Base
+    GROUP_NAME = 'Lua Scripts'.freeze
+
+    handles method_call(:defscript)
+    namespace_only
+
+    process do
+      method_name = statement.parameters[0].jump(:ident).source
+      method_body = strip_heredoc(statement.parameters[1].source)
+
+      script = YARD::CodeObjects::MethodObject.new(namespace, method_name, scope)
+      script.parameters = [['keys', []], ['argv', []]]
+      script.source = method_body
+      script.source_type = :lua
+      script.dynamic = true
+      script.group = GROUP_NAME
+
+      register(script)
+    end
+
+    def strip_heredoc(string)
+      if string.start_with?('<<')
+        lines = string.split("\n")
+        string = lines[1...-1].join("\n").strip
+      end
+
+      return string
+    end
+    private :strip_heredoc
+  end
+end

data/lib/redstruct.rb

@@ -0,0 +1,65 @@
+# Dependencies
+require 'redis'
+require 'connection_pool'
+
+# Utility
+require 'redstruct/version'
+require 'redstruct/utils/inspectable'
+require 'redstruct/utils/scriptable'
+require 'redstruct/utils/coercion'
+
+# Core
+require 'redstruct/connection'
+require 'redstruct/configuration'
+require 'redstruct/error'
+require 'redstruct/types/base'
+
+# Factory
+require 'redstruct/factory/creation'
+require 'redstruct/factory/deserialization'
+require 'redstruct/factory'
+
+# Base data types
+require 'redstruct/types/struct'
+require 'redstruct/types/string'
+require 'redstruct/types/counter'
+require 'redstruct/types/hash'
+require 'redstruct/types/list'
+require 'redstruct/types/script'
+require 'redstruct/types/set'
+require 'redstruct/types/sorted_set'
+
+module Redstruct
+  class << self
+    def config
+      return @config ||= Configuration.new
+    end
+
+    def factories
+      return @factories ||= {}
+    end
+
+    def [](key)
+      factory = factories[key]
+      factory = make(name: key) if factory.nil?
+
+      return factory
+    end
+
+    def []=(key, factory)
+      if factory.nil?
+        factories.delete(key)
+      else
+        factories[key] = factory
+      end
+    end
+
+    def make(name: nil, pool: nil, namespace: nil)
+      factory = Redstruct::Factory.new(pool: pool, namespace: namespace)
+      name = Redstruct if name.nil?
+      self[name] = factory unless name.nil?
+
+      return factory
+    end
+  end
+end

data/test/redstruct/restruct_test.rb

@@ -0,0 +1,4 @@
+require 'test_helper'
+
+class RedstructTest < Minitest::Test
+end

data/test/test_helper.rb

@@ -0,0 +1,4 @@
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+require 'redis/data'
+
+require 'minitest/autorun'

metadata

@@ -0,0 +1,145 @@
+--- !ruby/object:Gem::Specification
+name: redstruct
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Nicolas Pepin-Perreault
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-09-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.3'
+- !ruby/object:Gem::Dependency
+  name: connection_pool
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.2'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.12'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+description: Provides higher level data structures in Ruby using standard Redis commands.
+  Also provides basic object mapping for pre-existing types.
+email:
+- nicolas.pepin-perreault@offerista.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- Rakefile
+- lib/redstruct.rb
+- lib/redstruct/configuration.rb
+- lib/redstruct/connection.rb
+- lib/redstruct/error.rb
+- lib/redstruct/factory.rb
+- lib/redstruct/factory/creation.rb
+- lib/redstruct/factory/deserialization.rb
+- lib/redstruct/hls.rb
+- lib/redstruct/hls/lock.rb
+- lib/redstruct/hls/queue.rb
+- lib/redstruct/types/base.rb
+- lib/redstruct/types/counter.rb
+- lib/redstruct/types/hash.rb
+- lib/redstruct/types/list.rb
+- lib/redstruct/types/script.rb
+- lib/redstruct/types/set.rb
+- lib/redstruct/types/sorted_set.rb
+- lib/redstruct/types/string.rb
+- lib/redstruct/types/struct.rb
+- lib/redstruct/utils/coercion.rb
+- lib/redstruct/utils/inspectable.rb
+- lib/redstruct/utils/scriptable.rb
+- lib/redstruct/version.rb
+- lib/redstruct/yard/defscript_handler.rb
+- test/redstruct/restruct_test.rb
+- test/test_helper.rb
+homepage: https://npepinpe.github.com/redstruct/
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.6
+signing_key: 
+specification_version: 4
+summary: Higher level data structures for Redis.
+test_files:
+- test/redstruct/restruct_test.rb
+- test/test_helper.rb