redstruct 0.1.6 → 0.1.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b037a49dda3d7e960996e6fbc0c9bbc5ffe6445c
-  data.tar.gz: 221f64d42c69a93802971c6e8ecf425dd598ac22
+  metadata.gz: 5f29df0c24d1d453a2a24b5e32cf563d284e08d2
+  data.tar.gz: 26f083074180af497290197bb09a956d98e6c683
 SHA512:
-  metadata.gz: 94c3c5363a1f04b83cb6438fb07b22df54528fbc51d2f2820a8ffc46c59684bde7fd19ddd1aa83045fa109a7c7e7f94a6d3ce89339b535d751216142873b0987
-  data.tar.gz: 1754834360f2ae46fc748ba2b74bbafd322765424ac93f0b58594dadd52974661810771ad22b2d5ceb1c59ea687ecc7fc8641e09212937ccfeca5f6c4ce5635e
+  metadata.gz: 0564b2207e6b03a6e7109db3c634dd74ce33d891bfbfa23f0ad8531482c7a9ca93a02935901ef8edb4c8abaa0a9c8b7a6ff5a277ff199a95dd2d79548d59374a
+  data.tar.gz: b629606788ae08144cba7d154d9ecebe87d885f04fc74ea2472564a0b1e63559a9a50a8d44e14e583f9852341f622fe839095d3e461bf6697731462888d725b9

data/lib/redstruct/types/list.rb

@@ -32,9 +32,7 @@ module Redstruct
       end
 
       def pop(timeout: nil)
-        options = {}
-        options[:timeout] = timeout.to_i unless timeout.nil?
-        return self.connection.blpop(@key, options)&.last
+        return timeout.nil? ? self.connection.lpop(@key) : self.connection.blpop(@key, timeout: timeout)&.last
       end
 
       def remove(value, count: 1)

data/lib/redstruct/types/sorted_set.rb

@@ -1,14 +1,128 @@
+# frozen_string_literal: true
 module Redstruct
   module Types
     class SortedSet < Redstruct::Types::Struct
-      DEFAULT_SCORE = 1.0
+      # @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
 
-      def add(options = {}, *items)
-        defaults = { nx: false, xx: false, ch: false }
+      # @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 <<(item)
-        return self.connection.zadd(@key, DEFAULT_SCORE, item)
+        def parse_bound(bound)
+          case bound
+          when -Float::INFINITY
+            '-inf'
+          when Float::INFINITY
+            '+inf'
+          else
+            bound
+          end
+        end
       end
     end
   end

data/lib/redstruct/version.rb

@@ -1,3 +1,3 @@
 module Redstruct
-  VERSION = '0.1.6'.freeze
+  VERSION = '0.1.7'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: redstruct
 version: !ruby/object:Gem::Version
-  version: 0.1.6
+  version: 0.1.7
 platform: ruby
 authors:
 - Nicolas Pepin-Perreault
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-12-16 00:00:00.000000000 Z
+date: 2017-05-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis
@@ -145,7 +145,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 2.6.12
 signing_key: 
 specification_version: 4
 summary: Higher level data structures for Redis.