redstruct 0.1.7 → 0.2.0

data/lib/redstruct/types/base.rb

@@ -1,36 +0,0 @@
-module Redstruct
-  module Types
-    # Base class for all objects a factory can produce
-    class Base
-      include Redstruct::Utils::Inspectable
-      extend Forwardable
-
-      def_delegators :@factory, :connection, :connection
-
-      # @return [String] The key used to identify the struct on redis
-      attr_reader :key
-
-      def initialize(key:, factory:)
-        @factory = factory
-        @key = key
-      end
-
-      def to_h
-        return { key: @key }
-      end
-
-      def create
-        return unless block_given?
-        subfactory = @factory.factory(@key)
-        yield(subfactory)
-      end
-      protected :create
-
-      # :nocov:
-      def inspectable_attributes
-        { key: @key, factory: @factory }
-      end
-      # :nocov:
-    end
-  end
-end

data/lib/redstruct/types/counter.rb

@@ -1,65 +0,0 @@
-module Redstruct
-  module Types
-    class Counter < Redstruct::Types::String
-      include Redstruct::Utils::Scriptable
-
-      def initialize(increment: 1, max: nil, **options)
-        super(**options)
-        @increment = increment
-        @max = max
-      end
-
-      def get
-        super.to_i
-      end
-
-      def set(value, **options)
-        super(value.to_i, **options)
-      end
-
-      def increment(by: nil, max: nil)
-        by ||= @increment
-        max ||= @max
-
-        value = if max.nil?
-          self.connection.incrby(@key, by.to_i).to_i
-        else
-          ring_increment_script(keys: @key, argv: [by.to_i, max.to_i]).to_i
-        end
-
-        return value
-      end
-
-      def decrement(by: nil, max: nil)
-        by ||= @increment
-        by = -by.to_i
-        return increment(by: by, max: max)
-      end
-
-      def getset(value)
-        return super(value.to_i).to_i
-      end
-
-      # @!group Lua Scripts
-
-      defscript :ring_increment_script, <<~LUA
-        local by = tonumber(ARGV[1])
-        local max = tonumber(ARGV[2])
-        local current = redis.call('get', KEYS[1])
-        local value = current and tonumber(current) or 0
-
-        value = (value + by) % max
-        redis.call('set', KEYS[1], value)
-
-        return value
-      LUA
-
-      # @!endgroup
-
-      # Helper method for easy inspection
-      def inspectable_attributes
-        super.merge(max: @max, increment: @increment)
-      end
-    end
-  end
-end

data/lib/redstruct/types/hash.rb

@@ -1,72 +0,0 @@
-module Redstruct
-  module Types
-    class Hash < Redstruct::Types::Struct
-      include Redstruct::Utils::Coercion
-
-      def [](key)
-        return self.connection.hget(@key, key)
-      end
-
-      def []=(key, value)
-        self.connection.hset(@key, key, value)
-      end
-
-      def set(key, value, overwrite: true)
-        if overwrite
-          self[key] = value
-        else
-          self.connection.hsetnx(@key, key, value)
-        end
-      end
-
-      def get(*keys)
-        return self[keys.first] if keys.size == 1
-        return self.connection.mapped_hmget(@key, *keys)
-      end
-
-      def update(hash)
-        self.connection.mapped_hmset(@key, hash)
-      end
-
-      def remove(*keys)
-        return self.connection.hdel(@key, keys)
-      end
-
-      def key?(key)
-        return coerce_bool(self.connection.hexists(@key, key))
-      end
-
-      def incr(key, increment: 1)
-        if increment.is_a?(Float)
-          self.connection.hincrbyfloat(@key, key, increment.to_f)
-        else
-          self.connection.hincrby(@key, key, increment)
-        end
-      end
-
-      def decr(key, increment: 1)
-        return incr(key, -increment)
-      end
-
-      def to_h
-        return self.connection.hgetall(@key)
-      end
-
-      def keys
-        return self.connection.hkeys(@key)
-      end
-
-      def values
-        return self.connection.hvals(@key)
-      end
-
-      def size
-        return self.connection.hlen(@key)
-      end
-
-      def each(options = {}, &block)
-        return self.connection.hscan_each(@key, options, &block)
-      end
-    end
-  end
-end

data/lib/redstruct/types/list.rb

@@ -1,76 +0,0 @@
-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)
-        return timeout.nil? ? self.connection.lpop(@key) : self.connection.blpop(@key, timeout: timeout)&.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

@@ -1,56 +0,0 @@
-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

@@ -1,96 +0,0 @@
-# frozen_string_literal: true
-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)
-        list = self.connection.srandmember(@key, count)
-        return count == 1 ? list[0] : Set.new(list)
-      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
-        return self.connection.spop(@key)
-      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
-        end
-      end
-      private :coerce_destination
-    end
-  end
-end

data/lib/redstruct/types/sorted_set.rb

@@ -1,129 +0,0 @@
-# frozen_string_literal: true
-module Redstruct
-  module Types
-    class SortedSet < Redstruct::Types::Struct
-      # @param [Array<Array<#to_f, #to_s>>] pairs a list of pairs, where the first element is the score, and second the value
-      # @return [Integer] returns the amount of pairs inserted
-      def add(*pairs)
-        return self.connection.zadd(@key, pairs)
-      end
-
-      # @param [Array<#to_s>] values list of member values to remove from the set
-      # @return [Integer] the amount of elements removed
-      def remove(*values)
-        return self.connection.zrem(@key, values)
-      end
-
-      # Removes all items from the set. Does this by simply deleting the key
-      # @see Redstruct::Struct#delete
-      def clear
-        delete
-      end
-
-      # Returns the cardinality of the set
-      # @return [Integer] how many items are in the set
-      def size
-        return self.connection.zcard(@key)
-      end
-
-      # Returns the number of items between lower and upper bounds.
-      # By default lower and upper are inclusive. If you want to make them exclusive, prepend the value with "("
-      # @param [#to_s, #to_f] lower lower bound for the count range
-      # @param [#to_s, #to_f] upper upper bound for the count range
-      # @return [Integer] the number of items in the given range
-      def count(lower: nil, upper: nil)
-        return slice(lower: lower, upper: upper).size
-      end
-
-      # Returns a slice or partial selection of the set.
-      # @param [#to_s, #to_f] lower lower bound for the slice operation; it should be a simple float
-      # @param [#to_s, #to_f] upper upper bound for the slice operation; it should be a simple float
-      # @return [Redstruct::Types::SortedSet::Slice] sorted slice by given bounds, as list of pairs: (score, value)
-      def slice(lower: nil, upper: nil)
-        return self.class::Slice.new(self, lower: lower, upper: upper)
-      end
-
-      # Checks if the set contains any items.
-      # @return [Boolean] true if the key exists (meaning it contains at least 1 item), false otherwise
-      def empty?
-        return !self.connection.exists?
-      end
-
-      # @param [#to_s] item the item to check for
-      # @return [Boolean] true if the item is in the set, false otherwise
-      def contain?(item)
-        return !index(item).nil?
-      end
-      alias include? contain?
-
-      # Returns the index of the item in the set, sorted ascending by score
-      # @param [#to_s] item the item to check for
-      # @return [Integer, nil] the index of the item, or nil if not found
-      # @see Redis#zrank
-      def index(item)
-        return self.connection.zrank(@key, item)
-      end
-
-      # Returns the index of the item in the set, sorted descending by score
-      # @param [#to_s] item the item to check for
-      # @return [Integer, nil] the index of the item, or nil if not found
-      # @see Redis#zrevrank
-      def rindex(item)
-        return self.connection.zrevrank(@key, item)
-      end
-
-      # Returns an array representation of the set, sorted by score ascending
-      # NOTE: It pulls the whole set into memory, so use each if that's a concern
-      # @return [Array<Redstruct::Utils::ScoredValue>] all the items in the set, sorted by score ascending
-      # @see Redis#zrange
-      def to_a
-        return slice.to_a
-      end
-
-      # Utility class to allow operations on portions of the set only
-      class Slice
-        include Redstruct::Utils::Inspectable
-
-        # @param [String, Float] lower lower bound for the slice operation
-        # @param [String, Float] upper upper bound for the slice operation
-        def initialize(set, lower: nil, upper: nil)
-          @set = set
-          @lower = parse_bound(lower || '-inf')
-          @upper = parse_bound(upper || '+inf')
-        end
-
-        # @return [Array<String>] returns an array of values for the given scores
-        def to_a
-          @set.connection.zrangebyscore(@set.key, @lower, @upper)
-        end
-
-        # @return [Integer] the number of elements removed
-        def remove
-          @set.connection.zremrangebyscore(@set.key, @lower, @upper)
-        end
-
-        # @return [Integer] number of elements in the slice
-        def size
-          @set.connection.zcount(@set.key, @lower, @upper)
-        end
-
-        def inspectable_attributes
-          { lower: @lower, upper: @upper, set: @set }
-        end
-
-        private
-
-        def parse_bound(bound)
-          case bound
-          when -Float::INFINITY
-            '-inf'
-          when Float::INFINITY
-            '+inf'
-          else
-            bound
-          end
-        end
-      end
-    end
-  end
-end

data/lib/redstruct/types/string.rb

@@ -1,64 +0,0 @@
-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

@@ -1,58 +0,0 @@
-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
-
-      # Sets the key to expire after ttl seconds
-      # @param [Integer, #to_i] ttl the time to live in seconds (or milliseconds if ms is true)
-      # @param [Boolean] ms if true, assumes ttl is in milliseconds
-      def expire(ttl, ms: false)
-        if ms
-          self.connection.pexpire(@key, ttl.to_i)
-        else
-          self.connection.expire(@key, ttl.to_i)
-        end
-      end
-
-      # Sets the key to expire at the given timestamp.
-      # @param [Time, Integer, #to_i] time time or unix timestamp at which the key should expire
-      # @param [Boolean] ms if true, assumes the timestamp is in milliseconds
-      def expire_at(time, ms: false)
-        if ms
-          time = (time.to_f * 1000) if time.is_a?(Time)
-          self.connection.pexpireat(@key, time.to_i)
-        else
-          self.connection.expireat(@key, time.to_i)
-        end
-      end
-
-      # Removes the expiry time from a key
-      def persist
-        self.connection.persist(@key)
-      end
-
-      # @return [String] the underlying redis type
-      def type
-        self.connection.type(@key)
-      end
-
-      # :nocov:
-      def inspectable_attributes
-        super.merge(key: @key)
-      end
-      # :nocov:
-    end
-  end
-end

data/lib/releaser/logger.rb

@@ -1,15 +0,0 @@
-require 'logger'
-
-module Releaser
-  class Logger < ::Logger
-    TAG = '[RELEASER]'.freeze
-
-    def info(message)
-      super(TAG) { message }
-    end
-
-    def error(message)
-      super(TAG) { message }
-    end
-  end
-end

data/lib/releaser/repository.rb

@@ -1,32 +0,0 @@
-require 'english'
-
-module Releaser
-  class Repository
-    attr_reader :path
-
-    def initialize(path = '.')
-      @path = File.expand_path(path)
-      raise(Error, 'Unreadable path given') unless File.readable?(@path)
-      raise(Error, 'Repository is not a directory') unless File.directory?(@path)
-      raise(Error, 'Repository is not a github repository') unless git?
-    end
-
-    def git?
-      File.directory?("#{@path}/.git")
-    end
-
-    def clean?
-      committed = `git status -s`.chomp.strip.empty?
-      pushed = `git log origin/master..HEAD`.chomp.strip.empty?
-
-      return committed && pushed
-    end
-
-    def fetch_remote_tags
-      `git fetch --tags`
-      return $CHILD_STATUS.success?
-    end
-
-    class Error < StandardError; end
-  end
-end