relishable 0.9 → 0.10

data/lib/relish.rb

@@ -9,72 +9,72 @@ class Relish
   end
 
   def copy(id, version, data)
-    release = Release.new
-    release.item = {}
-    release.id = id
-    release.version = version
-    data.each do |k, v|
-      release.send("#{k}=", v.to_s) unless v.nil?
+    Release.new.tap do |release|
+      release.item = {}
+      release.id = id
+      release.version = version
+      data.each do |k, v|
+        release.send("#{k}=", v.to_s) unless v.nil?
+      end
+      @db.put(release.item)
     end
-    @db.put(release.item)
-    release
   end
 
   def create(id, data)
     item = @db.query_current_version(id)
-    release = Release.new
-    if item.nil?
-      release.item = {}
-      release.id = id
-      release.version = "1"
-    else
-      release.item = item
-      release.version = (release.version.to_i + 1).to_s
-    end
-    data.each do |k, v|
-      release.send("#{k}=", v.to_s) unless v.nil?
+    Release.new.tap do |release|
+      if item.nil?
+        release.item = {}
+        release.id = id
+        release.version = "1"
+      else
+        release.item = item
+        release.version = (release.version.to_i + 1).to_s
+      end
+      data.each do |k, v|
+        release.send("#{k}=", v.to_s) unless v.nil?
+      end
+      @db.put_current_version(release.item)
     end
-    @db.put_current_version(release.item)
-    release
   end
 
   def current(id, *attrs)
     item = @db.query_current_version(id, *attrs)
     unless item.nil?
-      release = Release.new
-      release.item = item
-      release
+      Release.new.tap do |release|
+        release.item = item
+      end
     end
   end
 
   def read(id, version, *attrs)
     item = @db.get_version(id, version, *attrs)
     unless item.nil?
-      release = Release.new
-      release.item = item
-      release
+      Release.new.tap do |release|
+        release.item = item
+      end
     end
   end
 
   def dump(id, consistent=nil, limit=nil)
-    items = @db.query(id, limit)
+    items = @db.query(id, consistent, limit)
     items.map do |item|
-      release = Release.new
-      release.item = item
-      release
+      Release.new.tap do |release|
+        release.item = item
+      end
     end
   end
 
   def update(id, version, data)
     item = @db.get_version(id, version)
     unless item.nil?
-      release = Release.new
-      release.item = item
-      data.each do |k, v|
-        release.send("#{k}=", v.to_s) unless v.nil?
+      Release.new.tap do |release|
+        release.item = item
+        data.each do |k, v|
+          release.send("#{k}=", v.to_s) unless v.nil?
+        end
+        @db.put_version(id, version, release.item)
       end
-      @db.put_version(id, version, release.item)
-      release
     end
   end
 end

data/lib/relish/dynamo_helper.rb

@@ -14,29 +14,27 @@ class Relish
     end
 
     def query_current_version(id, *attrs)
-      opts = set_attrs_on_opts(attrs, :ConsistentRead => true, :Limit => 1, :ScanIndexForward => false)
-      response = db.query(@table_name, {:S => id}, opts)
+      response = db.query(@table_name, {:S => id}, attrs_to_get(attrs).merge(:ConsistentRead => true, :Limit => 1, :ScanIndexForward => false))
       if response.body['Count'] == 1
         response.body['Items'].first
       end
     end
 
     def put_current_version(item)
-      response = db.put_item(@table_name, item, {:Expected => {:id => {:Exists => false}, :version => {:Exists => false}}})
+      db.put_item(@table_name, item, {:Expected => {:id => {:Exists => false}, :version => {:Exists => false}}})
     end
 
     def get_version(id, version, *attrs)
-      opts = set_attrs_on_opts(attrs)
-      response = db.get_item(@table_name, {:HashKeyElement => {:S => id}, :RangeKeyElement => {:N => version}}, opts)
+      response = db.get_item(@table_name, {:HashKeyElement => {:S => id}, :RangeKeyElement => {:N => version}}, attrs_to_get(attrs).merge(:ConsistentRead => true))
       response.body['Item']
     end
 
     def put_version(id, version, item)
-      response = db.put_item(@table_name, item, {:Expected => {:id => {:Value => {:S => id}}, :version => {:Value => {:N => version}}}})
+      db.put_item(@table_name, item, {:Expected => {:id => {:Value => {:S => id}}, :version => {:Value => {:N => version}}}})
     end
 
     def put(item)
-      response = db.put_item(@table_name, item)
+      db.put_item(@table_name, item)
     end
 
     def query(id, consistent, limit)
@@ -44,12 +42,14 @@ class Relish
       response.body['Items']
     end
 
+    def to_s
+      "#<Relish::DynamoHelper>"
+    end
+
     private
 
-    def set_attrs_on_opts(attrs, opts = {})
-      attrs = Array(attrs)
-      opts[:AttributesToGet] = attrs unless attrs.empty?
-      opts
+    def attrs_to_get(attrs)
+      attrs.empty? ? {} : {:AttributesToGet => attrs}
     end
   end
 end

data/lib/relish/encryption_helper.rb

@@ -12,20 +12,30 @@ class Relish
       @secrets = secrets
     end
 
-    def encrypt_env(env)
-      encrypt_key_with_secret("env", env, hmac_secrets.first)
+    def encrypt(key, value)
+      Fernet.generate(hmac_secrets.first) do |gen|
+        gen.data = {key => value}
+      end
     end
 
-    def decrypt_env(encrypted_token)
-      try_decrypt_with_index(encrypted_token)[0]
+    def decrypt(key, token)
+      hmac_secrets.each do |secret|
+        if verifier = verifier(secret, token)
+          return verifier.data[key] if verifier.valid?
+        end
+      end
+      raise RelishDecryptionFailed
     end
 
-    def upgrade_env_encryption(encrypted_token)
-      if encrypted_token.nil? || encrypted_token == ""
-        return false, encrypted_token
+    def upgrade(key, token)
+      if verifier = verifier(hmac_secrets.first, token)
+        return encrypt(key, verifier.data[key]) if verifier.valid?
       end
-      env, i = try_decrypt_with_index(encrypted_token)
-      i == 0 ? [false, encrypted_token] : [true, encrypt_env(env)]
+      raise RelishDecryptionFailed
+    end
+
+    def to_s
+      "#<Relish::EncryptionHelper>"
     end
 
     protected
@@ -36,36 +46,11 @@ class Relish
       end
     end
 
-    def try_decrypt_with_index(encrypted_token)
-      hmac_secrets.each_with_index do |secret, i|
-        success, env = try_decrypt_key(secret, encrypted_token, "env")
-        if success
-          return env, i
-        end
+    def verifier(secret, token)
+      Fernet.verifier(secret, token).tap do |verifier|
+        verifier.enforce_ttl = false
       end
-      raise RelishDecryptionFailed
-    end
-
-    def try_decrypt_key(secret, encrypted_token, hash_key)
-      verifier = Fernet.verifier(secret, encrypted_token)
-      verifier.enforce_ttl = false
-      unless verifier.valid?
-        return false, nil
-      end
-      [true, verifier.data[hash_key]]
-    rescue OpenSSL::Cipher::CipherError => e
-      return false, nil
-    end
-
-    def encrypt_key_with_secret(hash_key, value, secret)
-      Fernet.generate(secret) do |gen|
-        gen.data = {hash_key => value}
-      end
-    end
-
-    def inspect
-      "#<Relish::EncryptionHelper @static_secret=[masked] @secrets=[masked]>"
+    rescue OpenSSL::Cipher::CipherError
     end
-    alias to_s inspect
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: relishable
 version: !ruby/object:Gem::Version
-  version: '0.9'
+  version: '0.10'
   prerelease: 
 platform: ruby
 authors: