redstruct 0.1.7 → 0.2.0

data/test/redstruct/utils/scriptable_test.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require 'digest'
+require 'securerandom'
+require 'test_helper'
+
+module Redstruct
+  module Utils
+    class ScriptableTest < Redstruct::Test
+      def test_defscript
+        script = <<~LUA
+          local sum = 0
+          for i, key in ipairs(KEYS) do
+            local value = tonumber(ARGV[i])
+            redis.call("set", key, value)
+            sum = sum + value
+          end
+
+          return sum
+        LUA
+        script = script.strip
+        sha1 = Digest::SHA1.hexdigest(script)
+
+        klass = Class.new(Redstruct::Factory::Object) do
+          include Redstruct::Utils::Scriptable
+          defscript :test, script
+        end
+
+        assert_equal({ script: script, sha1: sha1 }, klass::SCRIPT_TEST, 'should have defined the constant properly')
+
+        factory = create_factory
+        keys = [factory.string(SecureRandom.hex(4)).key, factory.string(SecureRandom.hex(4)).key]
+        argv = [SecureRandom.random_number(10), SecureRandom.random_number(10)]
+        assert_equal argv.reduce(&:+), klass.new(factory: factory).test(keys: keys, argv: argv)
+
+        keys.each_with_index do |key, index|
+          assert_equal argv[index], factory.string(key).get.to_i, 'script should have set the value properly'
+        end
+      end
+
+      def test_const_defined
+        klass = Class.new { include Redstruct::Utils::Scriptable }
+        klass.const_set('SCRIPT_TEST', true)
+
+        stdout, = capture_subprocess_io { klass.defscript('test', 'return 0') }
+        assert_match(/WARN/, stdout, 'should produce a warning if the constant is already defined')
+        refute klass.method_defined?('test')
+        assert_equal true, klass::SCRIPT_TEST, 'should still be the old value'
+      end
+
+      def test_method_defined
+        klass = Class.new do
+          include Redstruct::Utils::Scriptable
+
+          def test
+            return true
+          end
+        end
+
+        stdout, = capture_subprocess_io { klass.defscript('test', 'return 0') }
+        assert_match(/WARN/, stdout, 'should produce a warning if the method is already defined')
+        refute klass.const_defined?('SCRIPT_TEST')
+        assert_equal true, klass.new.test, 'should still be the old value'
+      end
+    end
+  end
+end

data/test/redstruct_test.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+class RedstructTest < Redstruct::Test
+  # Test singleton property of the config
+  def test_config
+    config = Redstruct.config
+    assert_kind_of Redstruct::Configuration, config, 'Should return an instance of the configuration class'
+
+    reference = Redstruct.config
+    assert_equal config, reference, 'Should be a singleton object'
+  end
+end

data/test/test_helper.rb

@@ -1,4 +1,80 @@
+# frozen_string_literal: true
+
 $LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+require 'securerandom'
 require 'bundler/setup'
-require 'redstruct'
 require 'minitest/autorun'
+require 'flexmock/minitest'
+
+ci_build = ENV['CI_BUILD'].to_i.positive?
+
+bundler_groups = %i[default test]
+bundler_groups << (ci_build ? :ci : :debug)
+Bundler.require(*bundler_groups)
+
+# Start coverage
+Codacy::Reporter.start if ci_build
+
+# Default Redstruct config
+require 'redstruct/all'
+Redstruct.config.default_namespace = "redstruct:test:#{SecureRandom.uuid}"
+Redstruct.config.default_connection = ConnectionPool.new(size: 5, timeout: 2) do
+  Redis.new(host: ENV.fetch('REDIS_HOST', '127.0.0.1'), port: ENV.fetch('REDIS_PORT', 6379).to_i, db: ENV.fetch('REDIS_DB', 0).to_i)
+end
+
+# Setup cleanup hook
+Minitest.after_run do
+  Redstruct.config.default_connection.with do |conn|
+    conn.flushdb
+    conn.script(:flush)
+  end
+end
+
+# Small class used to generate thread-safe sequence when creating per-test
+# factories
+class AtomicInteger
+  def initialize
+    @lock = Mutex.new
+    @current = 0
+  end
+
+  def incr
+    value = nil
+    @lock.synchronize do
+      value = @current
+      @current += 1
+    end
+
+    return value
+  end
+end
+
+module Redstruct
+  # Base class for all Redstruct tests. Configures the gem, provides a default factory, and makes sure to clean it up
+  # at the end
+  class Test < Minitest::Test
+    @@counter = AtomicInteger.new # rubocop: disable Style/ClassVars
+
+    parallelize_me!
+    make_my_diffs_pretty!
+
+    # Use this helper to create a factory that the test class will keep track of and remove at the end
+    def create_factory(namespace = nil)
+      namespace ||= "#{Redstruct.config.default_namespace}:#{@@counter.incr}"
+      return Redstruct::Factory.new(namespace: namespace)
+    end
+
+    # Helper when trying to ensure a particular redis-rb command was called
+    # while still calling it. This allows for testing things outside of our
+    # control (e.g. srandmember returning random items)
+    # The reason we don't simply just mock the return value is to ensure
+    # that tests will break if a command (e.g. srandmember) changes its return
+    # value
+    def ensure_command_called(object, command, *args, allow: true)
+      mock = flexmock(object.connection).should_receive(command).with(object.key, *args)
+      mock = mock.pass_thru if allow
+
+      return mock
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: redstruct
 version: !ruby/object:Gem::Version
-  version: 0.1.7
+  version: 0.2.0
 platform: ruby
 authors:
 - Nicolas Pepin-Perreault
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-05-12 00:00:00.000000000 Z
+date: 2017-05-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis
@@ -50,14 +50,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.12'
+        version: '1.13'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.12'
+        version: '1.13'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -78,14 +78,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '5.0'
+        version: '5.1'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '5.0'
+        version: '5.1'
 description: Provides higher level data structures in Ruby using standard Redis commands.
   Also provides basic object mapping for pre-existing types.
 email:
@@ -97,33 +97,47 @@ files:
 - README.md
 - Rakefile
 - lib/redstruct.rb
+- lib/redstruct/all.rb
 - lib/redstruct/configuration.rb
-- lib/redstruct/connection.rb
+- lib/redstruct/connection_proxy.rb
+- lib/redstruct/counter.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/factory/object.rb
+- lib/redstruct/hash.rb
+- lib/redstruct/list.rb
+- lib/redstruct/lock.rb
+- lib/redstruct/script.rb
+- lib/redstruct/set.rb
+- lib/redstruct/sorted_set.rb
+- lib/redstruct/sorted_set/slice.rb
+- lib/redstruct/string.rb
+- lib/redstruct/struct.rb
 - lib/redstruct/utils/coercion.rb
 - lib/redstruct/utils/inspectable.rb
+- lib/redstruct/utils/iterable.rb
 - lib/redstruct/utils/scriptable.rb
 - lib/redstruct/version.rb
-- lib/releaser/logger.rb
-- lib/releaser/repository.rb
-- lib/tasks/release.rake
 - lib/yard/defscript_handler.rb
-- test/redstruct/restruct_test.rb
+- test/redstruct/configuration_test.rb
+- test/redstruct/connection_proxy_test.rb
+- test/redstruct/counter_test.rb
+- test/redstruct/factory/object_test.rb
+- test/redstruct/factory_test.rb
+- test/redstruct/hash_test.rb
+- test/redstruct/list_test.rb
+- test/redstruct/lock_test.rb
+- test/redstruct/script_test.rb
+- test/redstruct/set_test.rb
+- test/redstruct/sorted_set/slice_test.rb
+- test/redstruct/sorted_set_test.rb
+- test/redstruct/string_test.rb
+- test/redstruct/struct_test.rb
+- test/redstruct/utils/coercion_test.rb
+- test/redstruct/utils/inspectable_test.rb
+- test/redstruct/utils/iterable_test.rb
+- test/redstruct/utils/scriptable_test.rb
+- test/redstruct_test.rb
 - test/test_helper.rb
 homepage: https://npepinpe.github.com/redstruct/
 licenses:
@@ -150,5 +164,23 @@ signing_key:
 specification_version: 4
 summary: Higher level data structures for Redis.
 test_files:
-- test/redstruct/restruct_test.rb
+- test/redstruct/configuration_test.rb
+- test/redstruct/connection_proxy_test.rb
+- test/redstruct/counter_test.rb
+- test/redstruct/factory/object_test.rb
+- test/redstruct/factory_test.rb
+- test/redstruct/hash_test.rb
+- test/redstruct/list_test.rb
+- test/redstruct/lock_test.rb
+- test/redstruct/script_test.rb
+- test/redstruct/set_test.rb
+- test/redstruct/sorted_set/slice_test.rb
+- test/redstruct/sorted_set_test.rb
+- test/redstruct/string_test.rb
+- test/redstruct/struct_test.rb
+- test/redstruct/utils/coercion_test.rb
+- test/redstruct/utils/inspectable_test.rb
+- test/redstruct/utils/iterable_test.rb
+- test/redstruct/utils/scriptable_test.rb
+- test/redstruct_test.rb
 - test/test_helper.rb

data/lib/redstruct/connection.rb

@@ -1,47 +0,0 @@
-module Redstruct
-  class Connection
-    # @return [Array<Symbol>] List of methods from the Redis class that we don't want to delegate to.
-    NON_COMMAND_METHODS = [:[], :[]=, :_eval, :_scan, :method_missing, :call, :dup, :inspect, :to_s].freeze
-
-    attr_reader :pool
-
-    def initialize(pool)
-      raise(Redstruct::Error, 'Requires a ConnectionPool to proxy to') unless pool.is_a?(ConnectionPool)
-      @pool = pool
-    end
-
-    # Executes the given block by first fixing a thread local connection from the pool,
-    # such that all redis commands executed within the block are on the same connection.
-    # This is necessary when doing pipelining, or multi/exec stuff
-    # @return [Object] whatever the passed block evaluates to, nil otherwise
-    def with
-      result = nil
-      @pool.with do |c|
-        begin
-          Thread.current[:__redstruct_connection] = c
-          result = yield(c) if block_given?
-        ensure
-          Thread.current[:__redstruct_connection] = nil
-        end
-      end
-
-      return result
-    end
-
-    # While slower on load, defining all methods that we want to pipe to one of the connections results in
-    # faster calls at runtime, and gives us the convenience of not going through the pool.with everytime.
-    Redis.public_instance_methods(false).each do |method|
-      next if NON_COMMAND_METHODS.include?(method)
-      class_eval <<~METHOD, __FILE__, __LINE__ + 1
-        def #{method}(*args, &block)
-          connection = Thread.current[:__redstruct_connection]
-          if connection.nil?
-            with { |c| c.#{method}(*args, &block) }
-          else
-            return connection.#{method}(*args, &block)
-          end
-        end
-      METHOD
-    end
-  end
-end

data/lib/redstruct/factory/creation.rb

@@ -1,95 +0,0 @@
-module Redstruct
-  class Factory
-    # Module to hold all the factory creation methods.
-    module Creation
-      # Builds a struct with the given key (namespaced) and sharing the factory connection
-      # Building a struct is only really useful if you plan on making only basic operations,
-      # such as delete, expire, etc. It is however recommended to always build your objects
-      # in the same way, e.g. if it's a lock, use Factory#lock
-      # @param [::String] key base key to use
-      # @return [Redstruct::Types::Struct] base struct pointing to that key
-      def struct(key, **options)
-        return create(Redstruct::Types::Struct, key, **options)
-      end
-
-      # Builds a Redis string struct from the key
-      # @param [::String] key base key to use
-      # @return [Redstruct::Types::String]
-      def string(key, **options)
-        return create(Redstruct::Types::String, key, **options)
-      end
-
-      # Builds a Redis list struct from the key
-      # @param [::String] key base key to use
-      # @return [Redstruct::Types::List]
-      def list(key, **options)
-        return create(Redstruct::Types::List, key, **options)
-      end
-
-      # Builds a Redis set struct from the key
-      # @param [::String] key base key to use
-      # @return [Redstruct::Types::Set]
-      def set(key, **options)
-        return create(Redstruct::Types::Set, key, **options)
-      end
-
-      # Builds a Redis sorted set (zset) struct from the key
-      # @param [::String] key base key to use
-      # @return [Redstruct::Types::SortedSet]
-      def sorted_set(key, **options)
-        return create(Redstruct::Types::SortedSet, key, **options)
-      end
-
-      # Builds a Redis hash struct from the key
-      # @param [::String] key base key to use
-      # @return [Redstruct::Types::Hash]
-      def hash(key, **options)
-        return create(Redstruct::Types::Hash, key, **options)
-      end
-
-      # Builds a Redis backed lock from the key
-      # @param [::String] key base key to use
-      # @return [Redstruct::Hls::Lock]
-      def lock(key, **options)
-        return create(Redstruct::Hls::Lock, key, **options)
-      end
-
-      # Builds a Redis counter struct from the key
-      # @param [::String] key base key to use
-      # @return [Redstruct::Types::Counter]
-      def counter(key, **options)
-        return create(Redstruct::Types::Counter, key, **options)
-      end
-
-      # Builds a Redis backed queue from the key
-      # @param [::String] key base key to use
-      # @return [Redstruct::Hls::Queue]
-      def queue(key)
-        return create(Redstruct::Hls::Queue, key)
-      end
-
-      # @todo The script cache is actually based on the database you will connect to. Therefore, it might be smarter to move it to the connection used?
-      # Caveat: if the script with the given ID exists in the cache, we don't bother updating it.
-      # So if the script actually changed since the first call, the one sent during the first call will
-      def script(id, script)
-        return @script_cache.synchronize do
-          @script_cache[id] = Redstruct::Types::Script.new(key: id, script: script, factory: self) if @script_cache[id].nil?
-          @script_cache[id]
-        end
-      end
-
-      # Returns a factory with an isolated namespace.
-      # @example Given a factory `f` with namespace fact:first
-      #   f.factory('second') # => Redstruct::Factory: namespace: <"fact:first:second">, script_cache: <[]>
-      # @return [Factory] namespaced factory
-      def factory(namespace)
-        return self.class.new(connection: @connection, namespace: isolate(namespace))
-      end
-
-      def create(type, key, **options)
-        return type.new(key: isolate(key), factory: self, **options)
-      end
-      private :create
-    end
-  end
-end

data/lib/redstruct/factory/deserialization.rb

@@ -1,7 +0,0 @@
-module Redstruct
-  class Factory
-    # Module to hold all the factory creation methods.
-    module Deserialization
-    end
-  end
-end

data/lib/redstruct/hls/lock.rb

@@ -1,175 +0,0 @@
-require 'securerandom'
-
-module Redstruct
-  module Hls
-    # Implementation of a simple binary lock (locked/not locked), with option to block and wait for the lock.
-    # Uses two redis structures: a string for the lease, and a list for blocking operations.
-    # @see #acquire
-    # @see #release
-    # @see #locked
-    # @attr_reader [::String, nil] token the current token or nil
-    # @attr_reader [Fixnum] expiry expiry of the underlying redis structures in milliseconds
-    # @attr_reader [Fixnum, nil] timeout the timeout to wait when attempting to acquire the lock, in seconds
-    class Lock < Redstruct::Types::Base
-      include Redstruct::Utils::Scriptable, Redstruct::Utils::Coercion
-
-      # The default expiry on the underlying redis keys, in milliseconds
-      DEFAULT_EXPIRY = 1000
-
-      # The default timeout when blocking, in seconds; a nil value means it is non-blocking
-      DEFAULT_TIMEOUT = nil
-
-      attr_reader :token, :expiry, :timeout
-
-      # @param [Integer] expiry in milliseconds; to prevent infinite locking, each mutex is released after a certain expiry time
-      # @param [Integer] timeout in seconds; if > 0, will block for this amount of time when trying to obtain the lock
-      def initialize(expiry: DEFAULT_EXPIRY, timeout: DEFAULT_TIMEOUT, **options)
-        super(**options)
-
-        @token = nil
-        @expiry = expiry
-        @timeout = timeout.to_i
-
-        create do |factory|
-          @lease = factory.string('lease')
-          @tokens = factory.list('tokens')
-        end
-      end
-
-      # Executes the given block if the lock can be acquired
-      # @yield Block to be executed if the lock is acquired
-      def locked
-        yield if acquire
-      ensure
-        release
-      end
-
-      # Whether or not the lock will block when attempting to acquire it
-      # @return [Boolean]
-      def blocking?
-        return @timeout.positive?
-      end
-
-      # Attempts to acquire the lock. First attempts to grab the lease (a redis string).
-      # If the current token is already the lease token, the lock is considered acquired.
-      # If there is no current lease, then sets it to the current token.
-      # If there is a current lease that is not the current token, then:
-      #   1) If this not a blocking lock (see Lock#blocking?), return false
-      #   2) If this is a blocking lock, block and wait for the next token to be pushed on the tokens list
-      #   3) If a token was pushed, set it as our token and refresh the expiry
-      # @return [Boolean] True if acquired, false otherwise
-      def acquire
-        acquired = false
-        token = non_blocking_acquire(@token)
-        token = blocking_acquire if token.nil? && blocking?
-
-        unless token.nil?
-          @token = token
-          acquired = true
-        end
-
-        return acquired
-      end
-
-      # Releases the lock only if the current token is the value of the lease.
-      # If the lock is a blocking lock (see Lock#blocking?), push the next token on the tokens list.
-      # @return [Boolean] True if released, false otherwise
-      def release
-        return false if @token.nil?
-
-        next_token = SecureRandom.uuid
-        return coerce_bool(release_script(keys: [@lease.key, @tokens.key], argv: [@token, next_token, @expiry]))
-      end
-
-      def non_blocking_acquire(token = nil)
-        token ||= generate_token
-        return acquire_script(keys: @lease.key, argv: [token, @expiry])
-      end
-      private :non_blocking_acquire
-
-      def blocking_acquire
-        timeout = @timeout == Float::INFINITY ? 0 : @timeout
-        token = @tokens.pop(timeout: timeout)
-
-        # Attempt to reacquire in a non blocking way to:
-        # 1) assert we do own the lock (edge case)
-        # 2) touch the lock expiry
-        token = non_blocking_acquire(token) unless token.nil?
-
-        return token
-      end
-      private :blocking_acquire
-
-      # The acquire script attempts to set the lease (keys[1]) to the given token (argv[1]), only
-      # if it wasn't already set. It then compares to check if the value of the lease is that of the token,
-      # and if so refreshes the expiry (argv[2]) time of the lease.
-      # @param [Array<(::String)>] keys The lease key specifying who owns the mutex at the moment
-      # @param [Array<(::String, Fixnum)>] argv The current token; the expiry time in milliseconds
-      # @return [::String] Returns the token if acquired, nil otherwise.
-      defscript :acquire_script, <<~LUA
-        local token = ARGV[1]
-        local expiry = tonumber(ARGV[2])
-
-        redis.call('set', KEYS[1], token, 'NX')
-        if redis.call('get', KEYS[1]) == token then
-          redis.call('pexpire', KEYS[1], expiry)
-          return token
-        end
-
-        return false
-      LUA
-
-      # The release script compares the given token (argv[1]) with the lease value (keys[1]); if they are the same,
-      # then a new token (argv[2]) is set as the lease, and pushed on the tokens (keys[2]) list
-      # for the next acquire request.
-      # @param [Array<(::String, ::String)>] keys The lease key; the tokens list key
-      # @param [Array<(::String, ::String, Fixnum)>] argv The current token; the next token to push; the expiry time of both keys
-      # @return [Fixnum] 1 if released, 0 otherwise
-      defscript :release_script, <<~LUA
-        local currentToken = ARGV[1]
-        local nextToken = ARGV[2]
-        local expiry = tonumber(ARGV[3])
-
-        if redis.call('get', KEYS[1]) == currentToken then
-          redis.call('set', KEYS[1], nextToken, 'PX', expiry)
-          redis.call('lpush', KEYS[2], nextToken)
-          redis.call('pexpire', KEYS[2], expiry)
-          return true
-        end
-
-        return false
-      LUA
-
-      # @!group Serialization
-      # Returns a hash representation of the object
-      # @see Lock#from_h
-      # @return [Hash<Symbol, Object>] hash representation of the lock
-      def to_h
-        return super.merge(token: @token, expiry: @expiry, timeout: @timeout)
-      end
-
-      class << self
-        # Builds a lock from a hash.
-        # @see Lock#to_h
-        # @see Factory#create_from_h
-        # @param [Hash] hash hash generated by calling Lock#to_h. Ensure beforehand that keys are symbols.
-        # @return [Lock]
-        def from_h(hash, factory)
-          hash[:factory] = factory
-          return new(**hash)
-        end
-      end
-      # @!endgroup
-
-      def generate_token
-        return SecureRandom.uuid
-      end
-      private :generate_token
-
-      # Helper method for easy inspection
-      def inspectable_attributes
-        super.merge(expiry: @expiry, blocking: blocking?)
-      end
-    end
-  end
-end

data/lib/redstruct/hls/queue.rb

@@ -1,29 +0,0 @@
-module Redstruct
-  module Hls
-    class Queue < Redstruct::Types::List
-      include Redstruct::Utils::Scriptable
-
-      def enqueue(*elements)
-        self.connection.rpush(@key, elements)
-      end
-
-      def dequeue(length: 1)
-        elements = dequeue_script(keys: @key, argv: length)
-        length == 1 ? elements.first : elements
-      end
-
-      # Dequeues up to argv[1] amount of items from the list at keys[1]
-      # @param [Array<(::String)>] keys The key of the list to dequeue from
-      # @param [Array<(Fixnum)>] argv The number of items to dequeue
-      # @return [Array] An array of items dequeued or an empty array
-      defscript :dequeue_script, <<~LUA
-        local length = tonumber(ARGV[1])
-        local elements = redis.call('lrange', KEYS[1], 0, length - 1)
-        redis.call('ltrim', KEYS[1], length, -1)
-
-        return elements
-      LUA
-      protected :dequeue_script
-    end
-  end
-end

data/lib/redstruct/hls.rb

@@ -1,2 +0,0 @@
-require 'redstruct/hls/lock'
-require 'redstruct/hls/queue'