volatile_wtf 0.0.4 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a3953d7df5d35fd562901234c1d6857fb8bf30faedd9260995a24ad953592bae
-  data.tar.gz: 0ee37dc66758146e026ce79662afc81a21d2c6fb136318314b8633c2922e2fc2
+  metadata.gz: 90040b494c7a8b70f8f1173b631125a854ab0befd4366e276900e86d9b3e30b5
+  data.tar.gz: e74bb044370dd600514fb6dbb02aecde06ff5b95ee6bbc798785422e5816b530
 SHA512:
-  metadata.gz: '090fc56acf621cbdbe34aadce952ed3d2c4d10edabb4f02af8fb39564761e7d2dbabbc7fcfde39a9d7326bd78c024af6bf1ebe35287ff4aff8364dd07f34b840'
-  data.tar.gz: 22dd81ca15265c37b266f985cfca1ae604985f128b15b3e1b307a44f273bb4532579a01ef1269cce465fdd01d7d5dc1e3c4deb784f606e0157515c3b1c5bbc8a
+  metadata.gz: b68c40f821cc5a2ce42979651fc229f503fc6a87d9253431e88cc0b2566163fb7e7df645c101c4a79582213f96e9d153d0ab97766fc1c3191d2ae6291bfe3cc3
+  data.tar.gz: 33e436ee753f87d8671cb83c5031073ac939b055068c566f9d02c1e7235b10e7cd83ca462642fb8d4becb1e6da03a0805d8094004d2b303c0f815c6733f2e5ec

data/README.md

@@ -1,12 +1,16 @@
 # VolatileWTF
 
-[![Gem Version](https://badge.fury.io/rb/volatile_wtf@2x.png)](https://badge.fury.io/rb/volatile_wtf)
+[![Gem Version](https://badge.fury.io/rb/volatile_wtf.png)](https://badge.fury.io/rb/volatile_wtf)
 
 A Ruby wrapper for [Volatile](https://volatile.wtf/), a key-value pair API that everyone can use.
 
+More documentation at [RDoc](https://www.rubydoc.info/gems/volatile_wtf).
+
 ## Installation
 
-`gem install volatile_wtf`
+```bash
+gem install volatile_wtf
+```
 
 or for a Gemfile:
 
@@ -20,12 +24,6 @@ bundle install
 
 ## Usage
 
-Don't forget to require the gem:
-
-```ruby
-require 'volatile_wtf'
-```
-
 ### Initialize storage object
 
 ```ruby
@@ -38,26 +36,24 @@ Storage = Volatile::Storage.new
 Storage['user_name'] = 'Alice' # => 'Alice'
 ```
 
-If you want to create a pair independent from your Storage, use `Storage.push`:
+If you want to create a pair independent from your Storage:
 
 ```ruby
-Storage.push('random_key', 'random_val')
+Storage.set('random_key', 'random_val')
 ```
 
-You can use symbols as keys, but you'll still have to use strings to get values.
+You can use symbols as keys, but it is not recommended.
 
 ### Retrieve a value by key
 
-Using `#[](key)` retrieves a key from current Storage instance:
-
 ```ruby
 Storage['user_name'] # => 'Alice'
 ```
 
-If you want to retrieve a value by a custom key independent from your Storage, use `Storage.pull`:
+If you want to retrieve a value by a custom key independent from your Storage, use `Storage.get`:
 
 ```ruby
-Storage.pull('random_key') # => 'random_val'
+Storage.get('random_key') # => 'random_val'
 ```
 
 ### `created` and `modified` timestamps
@@ -74,31 +70,39 @@ Storage.pull('random_key') # => 'random_val'
   Storage.modified('user_name') # => 2019-11-12 17:40:45 +0300
   ```
 
-### Salted keys (or simply key prefixes)
+### Namespaces
+
+Namespace is used for distinguishing keys from different Storages.
+
+#### Passing your own namespace
 
-Salt is used for keys to make them trackable within this gem.
+By default, Storage is initialized with a namaspace equal to `SecureRandom.hex[0..5]` and makes keys look like `0123ab_some` instead of just `some`. You can pass your own value like this:
 
-#### Passing your own salt
+```ruby
+Storage = Volatile::Storage.new('my_ns')
+```
 
-By default, Storage is initialized with salt equal to `SecureRandom.hex[0..5]` and makes keys look like `0123ab_some` instead of just `some`. You can pass your own salt value like this:
+Or you can change namespace later:
 
 ```ruby
-Storage = Volatile::Storage.new('my_own_salt')
+Storage.namespace = 'my_own_ns'
 ```
 
-#### Retrieving a real key name
+__Warning!__ You can loose links to previously stored data if you change a namespace.
+
+#### Generating a namespaced key name
 
-If you want to get a real (salted) key name, you should use `Storage#real_key`:
+If you want to get a namespaced key name, you should use `Storage#namespaced_key`:
 
 ```ruby
-Storage.real_key('nice_key') # => '0123ab_nice_key'
+Storage.namespaced_key('nice_key') # => '0123ab_nice_key'
 ```
 
-Don't forget that every `Volatile::Storage.new` has its own salt value.
+Don't forget that every `Volatile::Storage.new` has its own namespace.
 
 ### Hash conversion (`#to_h`)
 
-By default, `#to_h` generates a hash with friendly keys without salt:
+By default, `#to_h` generates a hash with friendly keys without a namespace:
 
 ```ruby
 {
@@ -107,10 +111,10 @@ By default, `#to_h` generates a hash with friendly keys without salt:
 }
 ```
 
-To generate a hash with real keys, use `with_real_keys: true` parameter:
+To generate a hash with namespaced keys, use `use_namespace: true` parameter:
 
 ```ruby
-Storage.to_h(with_real_keys: true)
+Storage.to_h(use_namespace: true)
 ```
 
 This will return the following result:

data/lib/volatile_wtf/cache.rb

@@ -0,0 +1,17 @@
+module Volatile
+  class Cache
+    attr_reader :storage
+
+    def initialize
+      @storage = {}
+    end
+
+    def save(key, value)
+      @storage[key] = value
+    end
+
+    def fetch(key, &block)
+      @storage.fetch(key) { block.call }
+    end
+  end
+end

data/lib/volatile_wtf/manager.rb

@@ -2,39 +2,56 @@ require 'net/http'
 require 'uri'
 
 module Volatile
-  class Manager
+  BASE_URL = 'https://volatile.wtf'
+
+  # Manages the server side of Volatile storage, handles API requests
+ class Manager
+    def initialize
+      @cache = Cache.new
+    end
+
     def store(key, value)
-      get_from uri_with key, value
+      get_from api_uri key, value
+      @cache.save(key, value)
     end
 
     def retrieve(key)
-      get_from uri_with key
+      @cache.fetch(key) { get_from api_uri key }
     end
 
-    def created_at(key)
-      resp = get_from uri_with key, nil, 'created'
-      Time.at(resp.to_i)
+    def reload(key)
+      fresh_value = get_from api_uri key
+      store(key, fresh_value)
     end
-    alias created created_at
 
-    def updated_at(key)
-      resp = get_from uri_with key, nil, 'modified'
-      Time.at(resp.to_i)
+    def created(key)
+      time = key_modificator key, :created
+      Time.at(time.to_i)
+    end
+    
+    def modified(key)
+      time = key_modificator key, :modified
+      Time.at(time.to_i)
     end
-    alias modified updated_at
 
     private
 
+    # API URI helper for accessing key modificators data
+    def key_modificator(key, mod)
+      get_from api_uri key, nil, mod
+    end
+
     def get_from(uri)
       Net::HTTP.get(uri)
     end
 
-    def uri_with(key = nil, value = nil, modifier = nil)
-      url = "https://volatile.wtf/?key=#{key}"
+    # Builds a Volatile API URI
+    def api_uri(key = nil, value = nil, modifier = nil)
+      url = "#{BASE_URL}/?key=#{key}"
       url << "&#{modifier}" if modifier
       url << "&val=#{value}" if value
 
       URI(url)
     end
   end
-end
+end

data/lib/volatile_wtf/storage.rb

@@ -1,51 +1,68 @@
 require 'securerandom'
 require 'set'
+
 module Volatile
   class Storage
-    attr_accessor :salt
-    attr_reader :key, :value
+    attr_accessor :namespace
 
-    def initialize(salt = nil)
-      @salt = salt || SecureRandom.hex[0..5]
+    def initialize(namespace = nil)
+      @namespace = namespace || SecureRandom.hex[0..5]
       @keys = Set.new
       @manager = Manager.new
     end
 
+    # Gets value by key (with a namespace)
+    # Returns a `Volatile::Pair` instance, so that #modified and #created
+    # are easily accessible.
     def [](key)
-      @manager.retrieve(real_key(key))
+      key = namespaced_key(key)
+      get(key)
     end
 
+    # Sets value for a given key (with a namespace). Keeps the key for later
+    # to use in `to_h`
     def []=(key, value)
-      @keys << real_key(key)
-      @manager.store(real_key(key), value)
+      key = namespaced_key(key)
+      @keys << key
+      set(key, value)
     end
 
-    def pull(key)
+    # Gets value by key (without a namespace)
+    # Returns a `Volatile::Pair` instance, so that #modified and #created
+    # are easily accessible.
+    def get(key)
       @manager.retrieve(key)
     end
 
-    def push(key, value)
+    # Sets value for a given key (without a namespace)
+    def set(key, value)
       @manager.store(key, value)
       { key => value }
     end
 
+    # Refetch cached key
+    def reload(key)
+      @manager.reload(key)
+    end
+
     def created(key)
-      @manager.created_at(real_key(key))
+      @manager.created(key)
     end
 
     def modified(key)
-      @manager.updated_at(real_key(key))
+      @manager.modified(key)
     end
 
-    def real_key(key)
-      "#{@salt}_#{key}"
+    # Generates a namespaced option for a key name
+    def namespaced_key(key)
+      "#{@namespace}_#{key}"
     end
 
-    def to_h(with_real_keys = false)
+    def to_h(use_namespace = false)
       manager = @manager
 
       @keys.each_with_object({}) do |key, hash|
-        hash_key = with_real_keys ? key : key.sub("#{@salt}_", '')
+        hash_key = use_namespace ? key : key.sub("#{@namespace}_", '')
         hash[hash_key] = manager.retrieve(key)
       end
     end

data/lib/volatile_wtf/version.rb

@@ -1,3 +1,3 @@
 module VolatileWtf
-  VERSION = "0.0.4"
+  VERSION = "1.0.0"
 end

data/lib/volatile_wtf.rb

@@ -1,3 +1,4 @@
+require 'volatile_wtf/cache'
 require 'volatile_wtf/manager'
 require 'volatile_wtf/storage'
 require 'volatile_wtf/version'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: volatile_wtf
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 1.0.0
 platform: ruby
 authors:
 - Uladzislau Andreyeu
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-11-12 00:00:00.000000000 Z
+date: 2019-11-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -66,6 +66,7 @@ files:
 - bin/console
 - bin/setup
 - lib/volatile_wtf.rb
+- lib/volatile_wtf/cache.rb
 - lib/volatile_wtf/manager.rb
 - lib/volatile_wtf/storage.rb
 - lib/volatile_wtf/version.rb
@@ -93,7 +94,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.0.6
 signing_key: 
 specification_version: 4
 summary: A Ruby wrapper for Volatile, a key-value pair API that everyone can use.