valkey-objects 0.1.9 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cd818b1fec7663dd86f7fe4242f3087a12cec34a66636e7778a1962d89a5b36b
-  data.tar.gz: c5f94e9df1a9c8a7cf18b630084e723961a07132e4b2220a73c46b07347af95b
+  metadata.gz: 8a6bb452e823041de80c00be7bbea235bb937feef6937cac1ec122dd216a47f9
+  data.tar.gz: 15edeaffe86bf2eb97360e78930befcba9a7ab41c4a9f9a56e99cd7fedba1e3e
 SHA512:
-  metadata.gz: 925b6628e084463efcd12e62910a18c51e54a023ebd71fec4971ad446a0cd8f61e029ae518512dec20d6ba1b0cef1425f85165d9a91234151458e93b7c19ffbb
-  data.tar.gz: 05aa6bd931bb40bae5749cdfd3d18dee3df39669db0efcbb77f51da761e522f2b690be7a37503e7cf100366d0f6610af49bcfa468d4ad84436139f77ecce8541
+  metadata.gz: 1380445b88e8949132e7967b16ece714f74a3118bab76373e7d412a95709a062b63b1bfe56844d0f315d0b672e66b0f4ba67761472ec4c816aadbfc1de7ddb57
+  data.tar.gz: 6871da9972c3489afbedf59fb356edf2ba340deb9e4fe4ff47e172e144bb99624e0707497ed89fe4042206ad650b3e83938eb6eca2ce82245625509619779a38

data/lib/valkey/objects/version.rb

@@ -2,6 +2,6 @@
 
 module Valkey
   module Objects
-    VERSION = "0.1.9"
+    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)
@@ -362,11 +496,74 @@ module VK
       return h
     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
+
   def self.[] k
     VK.redis.call("KEYS", k)
   end
 end
-

data/valkey-objects.gemspec

@@ -34,6 +34,9 @@ Gem::Specification.new do |spec|
   spec.add_dependency "redis-client"
   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
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: valkey-objects
 version: !ruby/object:Gem::Version
-  version: 0.1.9
+  version: 0.2.1
 platform: ruby
 authors:
 - Erik Olson
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-12-25 00:00:00.000000000 Z
+date: 2025-01-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis-client
@@ -52,6 +52,48 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  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: 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
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: A ruby valkey client inspired by the redis-objects gem.
 email:
 - xorgnak@gmail.com
@@ -59,20 +101,14 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- "#class.rb#"
 - CHANGELOG.md
 - CODE_OF_CONDUCT.md
 - LICENSE.txt
 - README.md
 - Rakefile
-- class.rb~
-- example.rb~
 - lib/valkey/objects.rb
 - lib/valkey/objects/version.rb
-- module.rb~
 - sig/valkey/objects.rbs
-- valkey-objects-0.1.0.gem
-- valkey-objects-0.1.1.gem
 - valkey-objects.gemspec
 homepage: https://github.com/xorgnak/valkey-client
 licenses:

data/#class.rb#

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-require 'valkey/objects'
-
-require 'pry'
-
-class Game
-  include VK
-  sortedset :points
-  queue :log
-  def initialize k
-    @id = k
-  end
-  def score p, h={ points: 1 }
-    self.points.poke p, h[:points]
-  end
-end
-
-@game = Hash.new { |h,k| h[k] = Game.new(k) }
-
-Pry.start

data/class.rb~

@@ -1,97 +0,0 @@
-# frozen_string_literal: true
-
-require 'valkey/objects'
-
-# Using ValKey Objects
-## Create your class object
-class ValKey
-  # 1. include valkey-objects layer
-  include VK
-  # 2. stitch your object together.
-  value :myvalue
-  counter :mycounter
-  hashkey :myhash
-  sortedset :mysortedset
-  set :myset
-  queue :myqueue
-  place :myplace
-  pipe :mypipe
-  toggle :mytoggle
-  # 3. define @id in initialize.
-  def initialize k
-    @id = k
-  end
-  # other stuff...
-end
-
-## then user it.
-puts %[=== Valkey Object Test ===]
-@x = ValKey.new("My Special Valkey object.")
-#### pub/sub pipe
-##### on message
-@x.mypipe.on { |msg| puts %[MSG]; ap msg }
-##### publish message
-@x.mypipe << "Pipe Connected!"
-### get/set string value...
-@x.myvalue.value = "Hello, World"
-### get/set/incr/decr float value...
-@x.mycounter.value = 1.2345
-### get/set key/value pairs...
-@x.myhash[:key] = "Value"
-### sort keys by score...
-#### set
-@x.mysortedset["my other key"] = 9.8
-#### poke/get
-@x.mysortedset.poke "my key", @x.mysortedset["my other key"]
-#### by high score
-@x.mysortedset.value { |i, e| ap %[Sorted Sets: i: #{i} e: #{e}] }
-### collect keys...
-@x.myset << "my member"
-@x.myset << "my new member"
-#### filter by regexp...
-h = @x.myset[/ new /]
-puts %[Filtered set members:]
-ap h
-#### each collection key....
-@x.myset.value { |i, e| puts %[Sets: i: #{i} e: #{e}] }
-### points by coordinates...
-@x.myplace.add "Palermo", 13.361389, 38.115556
-@x.myplace.add "Catania", 15.087269, 37.502669
-#### distance between points.
-distance = @x.myplace.distance "Palermo", "Catania"
-ap %[The meters between the points: #{distance}]
-#### places within radius by coordinates
-places = @x.myplace.radius 15.087269, 37.502669, 5000
-ap %[The places within 5000 meters of the coordinates: #{places}]
-puts %[Place Values...]
-#### collection of places...
-@x.myplace.value { |i, e| puts %[Places: i: #{i} e: #{e}] }
-ap VK['*']
-
-
-
-## Or as a collection of "X"s...
-module X
-  @@X = Hash.new { |h,k| h[k] = Ex.new(k) }
-  class Ex
-    include VK
-    set :stuff
-    pipe :ear
-    def initialize k
-      @id = k
-    end
-  end
-  def self.keys
-    @@X.keys
-  end
-  def self.[] k
-    if !@@X.has_key?(k)
-      @@X[k].ear.on { |msg| puts "MSG[#{k}]:"; ap msg }
-    end
-    @@X[k]
-  end
-end
-
-@x[:a] = X['Aaa']
-@x[:b] = X['Bbb']
-@x[:c] = X['Ccc']

data/example.rb~

@@ -1,101 +0,0 @@
-# frozen_string_literal: true
-
-require 'valkey/objects'
-
-# Using ValKey Objects
-## Create your class object
-class ValKey
-  # 1. include valkey-objects layer
-  include VK
-  # 2. stitch your object together.
-  value :myvalue
-  counter :mycounter
-  hashkey :myhash
-  sortedset :mysortedset
-  set :myset
-  queue :myqueue
-  place :myplace
-  pipe :mypipe
-  toggle :mytoggle
-  # 3. define @id in initialize.
-  def initialize k
-    @id = k
-  end
-  # other stuff...
-end
-
-
-
-require 'awesome_print'
-
-@x = {}
-
-## then user it.
-puts %[=== Valkey Object Test ===]
-@x[:x] = ValKey.new("My Special Valkey object.")
-#### pub/sub pipe
-##### on message
-@x[:x].mypipe.on { |msg| puts %[MSG]; ap msg }
-##### publish message
-@x[:x].mypipe << "Pipe Connected!"
-### get/set string value...
-@x[:x].myvalue.value = "Hello, World"
-### get/set/incr/decr float value...
-@x[:x].mycounter.value = 1.2345
-### get/set key/value pairs...
-@x[:x].myhash[:key] = "Value"
-### sort keys by score...
-#### set
-@x[:x].mysortedset["my other key"] = 9.8
-#### poke/get
-@x[:x].mysortedset.poke "my key", @x[:x].mysortedset["my other key"]
-#### by high score
-@x[:x].mysortedset.value { |i, e| ap %[Sorted Sets: i: #{i} e: #{e}] }
-### collect keys...
-@x[:x].myset << "my member"
-@x[:x].myset << "my new member"
-#### filter by regexp...
-h = @x[:x].myset[/ new /]
-puts %[Filtered set members:]
-ap h
-#### each collection key....
-@x[:x].myset.value { |i, e| puts %[Sets: i: #{i} e: #{e}] }
-### points by coordinates...
-@x[:x].myplace.add "Palermo", 13.361389, 38.115556
-@x[:x].myplace.add "Catania", 15.087269, 37.502669
-#### distance between points.
-distance = @x[:x].myplace.distance "Palermo", "Catania"
-ap %[The meters between the points: #{distance}]
-#### places within radius by coordinates
-places = @x[:x].myplace.radius 15.087269, 37.502669, 5000
-ap %[The places within 5000 meters of the coordinates: #{places}]
-puts %[Place Values...]
-#### collection of places...
-@x[:x].myplace.value { |i, e| puts %[Places: i: #{i} e: #{e}] }
-ap VK['*']
-
-## Or as a collection of "X"s...
-module X
-  @@X = Hash.new { |h,k| h[k] = Ex.new(k) }
-  class Ex
-    include VK
-    set :stuff
-    pipe :ear
-    def initialize k
-      @id = k
-    end
-  end
-  def self.keys
-    @@X.keys
-  end
-  def self.[] k
-    if !@@X.has_key?(k)
-      @@X[k].ear.on { |msg| puts "MSG[#{k}]:"; ap msg }
-    end
-    @@X[k]
-  end
-end
-
-@x[:a] = X['Aaa']
-@x[:b] = X['Bbb']
-@x[:c] = X['Ccc']

data/module.rb~

@@ -1,57 +0,0 @@
-# frozen_string_literal: true
-
-require 'valkey/objects'
-
-# Using ValKey Objects
-## Create your class object
-class ValKey
-  # 1. include valkey-objects layer
-  include VK
-  # 2. stitch your object together.
-  value :myvalue
-  counter :mycounter
-  hashkey :myhash
-  sortedset :mysortedset
-  set :myset
-  queue :myqueue
-  place :myplace
-  pipe :mypipe
-  toggle :mytoggle
-  # 3. define @id in initialize.
-  def initialize k
-    @id = k
-  end
-  # other stuff...
-end
-
-
-
-require 'awesome_print'
-
-@x = {}
-
-## Or as a collection of "X"s...
-module X
-  @@X = Hash.new { |h,k| h[k] = Ex.new(k) }
-  class Ex
-    include VK
-    set :stuff
-    pipe :ear
-    def initialize k
-      @id = k
-    end
-  end
-  def self.keys
-    @@X.keys
-  end
-  def self.[] k
-    if !@@X.has_key?(k)
-      @@X[k].ear.on { |msg| puts "MSG[#{k}]:"; ap msg }
-    end
-    @@X[k]
-  end
-end
-
-X['Aaa'].ear << %[A]
-X['Bbb'].ear << %[B]
-X['Ccc'].ear << %[C]