valkey-objects 0.2.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 66451b3bbdc217925b068c50c8cdcd5cd392a6ddef99adbc7300c683c112d152
-  data.tar.gz: eb06049f2987c87b8cb7fb188e15960fab83d2f7a820205b3ddd06df1ed11828
+  metadata.gz: 8a6bb452e823041de80c00be7bbea235bb937feef6937cac1ec122dd216a47f9
+  data.tar.gz: 15edeaffe86bf2eb97360e78930befcba9a7ab41c4a9f9a56e99cd7fedba1e3e
 SHA512:
-  metadata.gz: 78d4470e2aa1cc2b9763265c7a940f4f2da58798460fbce998e2aedd32cdcd6136accca257d83719328e59011b6da185c59f590863642d430488966b9a77cb9e
-  data.tar.gz: ad6b0974b14ebd9bc022aa259a4a953556d5ec567d370a0335b279fc695f655713cba4d0499e8cb7d6bc15e610a5ba4918d8a81bdeca4ce8820bd0d65f8f6439
+  metadata.gz: 1380445b88e8949132e7967b16ece714f74a3118bab76373e7d412a95709a062b63b1bfe56844d0f315d0b672e66b0f4ba67761472ec4c816aadbfc1de7ddb57
+  data.tar.gz: 6871da9972c3489afbedf59fb356edf2ba340deb9e4fe4ff47e172e144bb99624e0707497ed89fe4042206ad650b3e83938eb6eca2ce82245625509619779a38

data/lib/valkey/objects/version.rb

@@ -2,6 +2,6 @@
 
 module Valkey
   module Objects
-    VERSION = "0.2.0"
+    VERSION = "0.2.1"
   end
 end

data/lib/valkey/objects.rb

@@ -5,8 +5,14 @@ require_relative "objects/version"
 require 'redis-client'
 require 'json'
 require 'ruby-duration'
+require 'amatch'
 require 'ap'
 module VK
+
+  @@XX = {}
+
+  
+  
   def self.included(x)
     x.extend VK
   end
@@ -16,6 +22,8 @@ module VK
     # Example:
     # class ExmpleObject
     #  include VK
+    #
+    ## Add Object Containers by Value Type:
     #  value :myValue
     #  counter :myCounter
     #  hashkey :myHashKey
@@ -25,49 +33,83 @@ module VK
     #  place :myPlace
     #  pipe :myPipe
     #  toggle :myToggle
+    #  ticker :myTicker
+    #  entry :myEntry
+    #
+    ## Add an Object Container With an Implicit Expiration:
+    #  value :myExpiringValue, ttl: (seconds to live without interaction)
+    #
     #  def initialize k
     #   @id = k
     #  end
     # end
-    #
-    # Instantiation: @obj = ExampleObject.new('object id...')
+    ##
+    # Create the Object:
+    # @obj = ExampleObject.new('object id...')
+    ##
+    # For all object methods:
+    # @obj.myObjectContainer.expire(seconds)
+    # @obj.myObjectContainer.delete!
+    # 
     xx = x.name.gsub("::", "-")
     ##
+    # Object Method Types: 
+    ##
+    # A String Value
+    ##
     # value :myValue
-    # @obj.myValue => A string
+    # @obj.myValue
+    # @obj.myValue.exist?
     # @obj.myValue.value = "my value"
     # @obj.myValue.value => "my value"
-    define_method(:value) { |k| define_method(k.to_sym) { V.new(%[#{xx}:value:#{k}:#{@id}]) } };
+    define_method(:value) { |k, h={}| define_method(k.to_sym) { VALUE.new(%[#{xx}:value:#{k}:#{@id}], h) } };
+    ##
+    # A Number Value 
     ##
-    # counter :myCounter => A number
+    # counter :myCounter
     # @obj.myCounter
+    # @obj.myCounter.exist?
     # @obj.myCounter.value = number
-    # @obj.myCounter.value => ...
+    # @obj.myCounter.value => number
     # @obj.myCounter.incr number                                                                                                                
     # @obj.myCounter.decr number    
     #
-    define_method(:counter) { |k| define_method(k.to_sym) { C.new(%[#{xx}:counter:#{k}:#{@id}]); } };
+    define_method(:counter) { |k, h={}| define_method(k.to_sym) { COUNTER.new(%[#{xx}:counter:#{k}:#{@id}], h); } };
     ##
-    # 
-    define_method(:timestamp) { |k| define_method(k.to_sym) { N.new(%[#{xx}:counter:#{k}:#{@id}]) } }
-    ##                                                                                                                                                
-    # hashkey :myHashKey => The ubiquitous Ruby Hash in valkey/redis
+    # An Epoch Value
+    ##
+    # timestamp :myTimestamp
+    # @obj.myTimestamp
+    # @obj.myTimestamp.exist?
+    # @obj.myTimestamp.value!
+    # @obj.myTimestamp.value => epoch
+    # @obj.myTimestamp.ago => Seconds since epoch
+    # @obj.myTimestamp.to_time => Time object
+    define_method(:timestamp) { |k, h={}| define_method(k.to_sym) { TIMESTAMP.new(%[#{xx}:timestamp:#{k}:#{@id}], h) } }
+    ##
+    # A Hash Value
+    ##
+    # hashkey :myHashKey
     # @obj.myHashKey
     # @obj.myHashKey[:key] = value
-    # @obj.myHashKey[:key] => ...
+    # @obj.myHashKey[:key] => "value"
     #
-    define_method(:hashkey) { |k| define_method(k.to_sym) { H.new(%[#{xx}:hash:#{k}:#{@id}]); } };
-    ##                                                                                                                                                
-    # sortedset :mySortedSet => A ranked collection of members
+    define_method(:hashkey) { |k, h={}| define_method(k.to_sym) { HASH.new(%[#{xx}:hashkey:#{k}:#{@id}], h); } };
+    ##
+    # A Sorted Set Value
+    ##
+    # sortedset :mySortedSet
     # @obj.mySortedSet
     # @obj.mySortedSet[:key] = value                                                                                                                 
     # @obj.mySortedSet[:key] => ...    
     # @obj.mySortedSet.value { |key, i| ... }
     # @obj.mySortedSet.poke key, number
     #
-    define_method(:sortedset) { |k| define_method(k.to_sym) { S.new(%[#{xx}:sortedset:#{k}:#{@id}]); } };
-    ##                                                                                                                                                
-    # set :mySet => A collect of unique members
+    define_method(:sortedset) { |k, h={}| define_method(k.to_sym) { SORTEDSET.new(%[#{xx}:sortedset:#{k}:#{@id}], h); } };
+    ##
+    # A Collection of Values
+    ##
+    # set :mySet
     # @obj.mySet
     # @obj.mySet << "x"
     # @obj.myset.rm "x"
@@ -76,17 +118,21 @@ module VK
     # @obj.myset["pattern"]
     # @obj.mySet.value { |key, i| ... }    
     #    
-    define_method(:set) { |k| define_method(k.to_sym) { G.new(%[#{xx}:set:#{k}:#{@id}]); } };
-    ##                                                                                                                                                
-    # queue :myQueue => An array with push and pop utility
+    define_method(:set) { |k, h={}| define_method(k.to_sym) { SET.new(%[#{xx}:set:#{k}:#{@id}], h); } };
+    ##
+    # A List of Values
+    ##
+    # queue :myQueue
     # @obj.myQueue
     # @obj.myQueue << "x"
     # @obj.myQueue.front => "x" and pop
     # @obj.myQueue.value { |key, i| ... }    
     #
-    define_method(:queue) { |k| define_method(k.to_sym) { Q.new(%[#{xx}:queue:#{k}:#{@id}]); } };
-    ##                                                                                                                                                
-    # place :myPlace => GPS Coordinates
+    define_method(:queue) { |k, h={}| define_method(k.to_sym) { QUEUE.new(%[#{xx}:queue:#{k}:#{@id}], h); } };
+    ##
+    # A Collection of Places
+    ##
+    # place :myPlace
     # @obj.myPlace
     # @obj.myPlace.add "key", longitude, latitude
     # @obj.myPlace["key"] => { longitude: xx, latitude: yy }
@@ -94,24 +140,45 @@ module VK
     # @obj.myPlace.radius longitude, latitude, distance
     # @obj.myPlace.value { |key, i| ... }
     #
-    define_method(:place) { |k| define_method(k.to_sym) { P.new(%[#{xx}:place:#{k}:#{@id}]); } };
-    ##                                                                                                                                                
-    # pipe :myPipe => Subscibe and handle, and publish.
-    # @obj.myPipe
-    # @obj.myPipe.on { |msg| ... }
-    # @obj.myPipe << "input" => publish { input: "input" }
-    # @obj.myPipe << ["input","input"] => publish { inputs: ["input", "input"] }
-    # @obj.myPipe << {} => publish {}
-    #
-    define_method(:pipe) { |k| define_method(k.to_sym) { B.new(%[#{xx}:pipe:#{k}:#{@id}]); } };
-    ##                                                                                                                                                
-    # toggle :myToggle => Boolean toggle.
+    define_method(:place) { |k, h={}| define_method(k.to_sym) { PLACE.new(%[#{xx}:place:#{k}:#{@id}], h); } };
+    ##
+    # A Boolean Value
+    ##
+    # toggle :myToggle
     # @obj.myToggle
-    # @obj.value = bool
-    # @obj.value => ...
-    # @obj.value! => value = !value
+    # @obj.myToggle.exist?
+    # @obj.myToggle.value = bool
+    # @obj.myToggle.value => ...
+    # @obj.myToggle.value! => value = !value
     #
-    define_method(:toggle) { |k| define_method(k.to_sym) { T.new(%[#{xx}:toggle:#{k}:#{@id}]); } };
+    define_method(:toggle) { |k, h={}| define_method(k.to_sym) { TOGGLE.new(%[#{xx}:toggle:#{k}:#{@id}], h); } };
+    ##
+    # A Sorted Hash of Values 
+    ##
+    # ticker :myTicker
+    # @obj.myTicker
+    # @obj.myTicker[:key] = value
+    # @obj.myTicker[:key] => "value"
+    # @obj.myticker.value { |i,e| ... }
+    define_method(:ticker) { |k, h={}| define_method(k.to_sym) { SORTEDHASH.new(%[#{xx}:ticker:#{k}:#{@id}], h); } };
+    ##
+    # A List of Hashes
+    ##
+    # entry :myEntry
+    # @obj.myEntry
+    # @obj.myEntry << { key: 'value', ... }
+    # @obj.myEntry.value { |i,e| ... }
+    define_method(:entry) { |k, h={}| define_method(k.to_sym) { HASHLIST.new(%[#{xx}:entry:#{k}:#{@id}], h); } };
+    ##
+    # A list of Strings
+    ##
+    # vector :myVector
+    # @obj.myVector
+    # @obj.myVector << "An Entry of Text."
+    # @obj.myVector.value { |i,e| ... }
+    # @obj.myvector[0] = "An Entry of Text."
+    define_method(:vector) { |k, h={}| define_method(k.to_sym) { VECTOR.new(%[#{xx}:vector:#{k}:#{@id}], h); } };
+    
   end
 
   def id
@@ -161,11 +228,15 @@ module VK
   def self.redis
     RedisClient.config(host: "127.0.0.1", port: 6379, db: 0).new_client
   end
-  
+
   class O
     attr_reader :key
-    def initialize k
+    def initialize k, h={}
       @key = k
+      @opts = h 
+      if @opts.has_key?(:ttl)
+        expire @opts[:ttl]
+      end
     end
     def delete!
       VK.redis.call("DEL", key);
@@ -175,13 +246,19 @@ module VK
     end
   end
 
-  class N < O
+  class TIMESTAMP < O
     def value
       VK.redis.call("GET", key).to_i;
+      if @opts.has_key?(:flush) == true
+        delete!
+      end
     end
     def value!
       VK.redis.call("SET", key, "#{VK.clock.to_i}");
     end
+    def exist?
+      VK.redis.call("GET", key) ? true : false
+    end
     def ago
       VK.clock.to_i - value;
     end
@@ -190,10 +267,16 @@ module VK
     end
   end
   
-  class T < O
+  class TOGGLE < O
     def value
-      VK.redis.call("GET", key) == 'true' ? true : false  
+      VK.redis.call("GET", key) == 'true' ? true : false
+      if @opts.has_key?(:flush) == true
+        delete!
+      end
     end
+    def exist?                                                                                                                                        
+      VK.redis.call("GET", key) ? true : false                                                                                                        
+    end    
     def value= x
        VK.redis.call("SET", key, "#{x.to_s}")
     end
@@ -206,42 +289,19 @@ module VK
     end
   end
   
-  class B < O
-    def on &b
-      pubsub = VK.redis.pubsub
-      pubsub.call("SUBSCRIBE", key)
-      Process.detach( fork do
-                        loop do
-                          if m = pubsub.next_event(0)
-                            cn, ty, na, id = key.split(":")
-                            if m[0] == "message"
-                              b.call({ stub: na, object: cn.gsub("-", "::"), type: ty, id: id, event: m[0], data: JSON.parse(m[2]) })
-                            else
-                              ap({ stub: na, object: cn.gsub("-", "::"), type: ty, id: id, event: m[0], data: m[2] })
-                            end
-                          end
-                        end
-                      end
-                    );
-    end
-    def << x
-      if x.class == String
-        VK.redis.call("PUBLISH", key, JSON.generate({ input: x }))
-      elsif x.class == Array
-        VK.redis.call("PUBLISH", key, JSON.generate({ inputs: x }))
-      elsif x.class == Hash
-        VK.redis.call("PUBLISH", key, JSON.generate(x))
-      end
-    end
-  end
-  
-  class V < O
+  class VALUE < O
     def value
       VK.redis.call("GET", key)
+      if @opts.has_key?(:flush) == true
+        delete!
+      end
     end
     def value= x
       VK.redis.call("SET", key, x)
     end
+    def exist?                                                                                                                                        
+      VK.redis.call("GET", key) ? true : false                                                                                                        
+    end
     def match r, &b
       m = Regexp.new(r).match(value)
       if block_given?
@@ -251,8 +311,48 @@ module VK
       end
     end
   end
+
+  class VECTOR < O
+    include Amatch
+    def value &b
+      VK.redis.call("LRANGE", key, 0, -1).each_with_index { |e, i|                                                                                    
+        b.call(i, VK.redis.call("GET", e))
+        if @opts.has_key?(:flush) == true
+          VK.redis.call("DEL", e);
+        end
+      }
+      if @opts.has_key?(:flush) == true
+        delete!
+      end
+    end
+    def [] k
+      VK.redis.call("GET", "#{@key}-#{k}");
+    end
+    def << i
+      kk = %[#{@key}-#{VK.redis.call("LLEN",@key)}]
+      VK.redis.call("SET", kk, i);
+      VK.redis.call("RPUSH", key, kk)
+    end
+    def nearest p
+      h = {}
+      value { |i,v|
+        h[i] = {
+                value: v,
+                levenshtein: p.levenshtein_similar(v),
+                damerau: p.damerau_levenshtein_similar(v),
+                hamming: p.hamming_similar(v),
+                distance: p.pair_distance_similar(v),
+                subsequence: p.longest_subsequence_similar(v),
+                substring: p.longest_substring_similar(v),
+                jaro: p.jaro_similar(v),
+                winkler: p.jarowinkler_similar(v)
+              }
+      }
+      return h
+    end
+  end 
   
-  class C < O
+  class COUNTER < O
     def incr n
       VK.redis.call("SET", key, value + n.to_f)
     end
@@ -261,27 +361,36 @@ module VK
     end    
     def value
       VK.redis.call("GET", key).to_f
+      if @opts.has_key?(:flush) == true                                                                                                               
+        delete!                                                                                                                                       
+      end      
     end
     def value= n
       VK.redis.call("SET", key, n.to_f)
     end
+    def exist?                                                                                                                                        
+      VK.redis.call("GET", key) ? true : false                                                                                                        
+    end    
   end
   
-  class H < O
+  class HASH < O
     def [] k
       VK.redis.call("HGET", key, k);
     end
     def []= k,v
-      VK.redis.call("HMSET", key, k, v);
+      VK.redis.call("HSET", key, k, v);
     end
     def to_h
       VK.redis.call("HGETALL", key);
     end
   end
   
-  class Q < O
+  class QUEUE < O
     def value &b
       VK.redis.call("LRANGE", key, 0, -1).each_with_index { |e, i| b.call(i, e) }
+      if @opts.has_key?(:flush) == true
+        delete!
+      end
     end
     def length
       VK.redis.call("LLEN", key)
@@ -294,9 +403,12 @@ module VK
     end
   end
   
-  class S < O
+  class SORTEDSET < O
     def value &b
       VK.redis.call("ZREVRANGE", key, 0, -1, 'WITHSCORES').each_with_index { |e, i| b.call(i, e) }
+      if @opts.has_key?(:flush) == true
+        delete!
+      end
     end
     def [] k
       VK.redis.call("ZSCORE", key, k).to_f;
@@ -309,9 +421,20 @@ module VK
     end
   end
 
-  class G < O
+  class SET < O
     def value &b
-      VK.redis.call("SMEMBERS", key).each_with_index { |e, i| b.call(i, e) }
+      a = Set.new
+      VK.redis.call("SMEMBERS", key).each_with_index { |e, i|
+        if block_given?
+          a << b.call(i, e)
+        else
+          a << e
+        end
+      }
+      if @opts.has_key?(:flush) == true
+        delete!
+      end
+      return aa
     end
     def include? k
       if VK.redis.call("SMISMEMBER", key, k)[0] == 0
@@ -342,9 +465,20 @@ module VK
     end
   end
   
-  class P < O
+  class PLACE < O
     def value &b
-      VK.redis.call("ZRANGE", key, 0, -1).each_with_index { |e, i| b.call(i, e) };
+      a = []
+      VK.redis.call("ZRANGE", key, 0, -1).each_with_index { |e, i|
+        if block_given?
+          a << b.call(i, e)
+        else
+          a << e
+        end
+      };
+      if @opts.has_key?(:flush) == true
+        delete!
+      end
+      return a
     end
     def add i, lon, lat
       VK.redis.call("GEOADD", key, lon, lat, i)
@@ -363,6 +497,68 @@ module VK
     end
   end
 
+  class SORTEDHASH < O
+    def value &b
+      VK.redis.call("ZREVRANGE", key, 0, -1, 'WITHSCORES').each_with_index { |e, i|
+        kx = %[#{@key}-#{e[0]}]
+        a = []
+        if block_given?
+          b.call(i, { key: e[0], value: VK.redis.call("GET", kx), score: e[1] } )
+        else
+          a << { key: e[0], value: VK.redis.call("GET", kx), score: e[1] }
+        end
+        if @opts.has_key?(:flush) == true
+          VK.redis.call("DEL", kx)
+        end
+      }
+      if @opts.has_key?(:flush) == true                                                                                                               
+        delete!                                                                                                                                       
+      end
+      return a
+    end
+    def [] k
+      kx = %[#{@key}-#{k}]
+      VK.redis.call("GET", kx)
+    end
+    def []= k, v
+      kx = %[#{@key}-#{k}]
+      VK.redis.call("SET", kx, v)
+      VK.redis.call("ZINCRBY", key, 1, k)
+    end
+  end
+
+  class HASHLIST < O
+    def value &b
+      a = []
+      VK.redis.call("LRANGE", key, 0, -1).each_with_index { |e, i|
+        if block_given?
+          a << b.call(i, JSON.parse(VK.redis.call("GET", e)))
+        else
+          a << JSON.parse(VK.redis.call("GET", e))
+        end
+        if @opts.has_key?(:flush) == true
+          VK.redis.call("DEL", e)
+        end
+      }
+      if @opts.has_key?(:flush) == true
+        delete!
+      end
+      return a
+    end
+    def length
+      VK.redis.call("LLEN", key)
+    end
+    def [] k
+      hx = %[#{key}-#{k}]
+      JSON.parse(VK.redis.call("GET", hx));      
+    end
+    def push h={}
+      hx = %[#{key}-#{length}]
+      VK.redis.call("SET", hx, JSON.generate(h));
+      VK.redis.call("RPUSH", key, hx)
+    end
+  end
+  
   def self.flushdb!
     VK.redis.call("FLUSHDB")
   end

data/valkey-objects.gemspec

@@ -35,6 +35,7 @@ Gem::Specification.new do |spec|
   spec.add_dependency "json"
   spec.add_dependency "ruby-duration"
   spec.add_dependency "pry"
+  spec.add_dependency "amatch"
   spec.add_dependency "awesome_print"
   # For more information and examples about making a new gem, check out our
   # guide at: https://bundler.io/guides/creating_gem.html

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: valkey-objects
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.1
 platform: ruby
 authors:
 - Erik Olson
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-01-12 00:00:00.000000000 Z
+date: 2025-01-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis-client
@@ -66,6 +66,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: amatch
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: awesome_print
   requirement: !ruby/object:Gem::Requirement