canery 0.1.3 → 0.1.4

data/README.md

@@ -1,5 +1,5 @@
 # Canery
-Canery is a simple and easy to use key/value store with several commands to store and retrieve data. As the backend uses [Sequel](https://github.com/jeremyevans/sequel/) for persistence, Canery can be used in virtually any environment where a SQL database is available. (For more information please check out the section in the Sequel documentation with the available database adapters.)
+Canery is a simple and easy to use key/value store with several commands to store and retrieve data. Canery uses [Sequel](https://github.com/jeremyevans/sequel/) for persistence, so it can be used in virtually any environment where a SQL database is available. (For more information about the available database adapters please check out the appropriate section in the Sequel documentation.)
 
 ## Installation
 	gem install canery
@@ -29,6 +29,9 @@ Canery provides a simple and understandable API which is a bit inspired by Redis
 
 	# Get this complex value
 	store.get("demo_hash") # => {:first_name => "John", :last_name => "Doe"}
+	
+	# If you set nil as key, Canery builds a uuid-key for you
+	store.set(nil, "oh my god, no key given!") # => "2cf7541a-00c1-4bda-8c75-fc32a5f5fac7"
 
 For more information consider the wiki. (Comming soon... I promise!)
 
@@ -37,7 +40,7 @@ Due to the nature of SQL databases it's (almost) impossible for Canery to be as
 
 ## Information about data types
 ### Keys & Tub names
-Theoretically every string can be used as a key/tub name, from a string like "foo" to the content of a JPEG file. Even an empty string is a valid key. But for better performance, short keys should be your first choice.
+Theoretically every string can be used as a key/tub name, from a string like "foo" to the serialized content of a PNG file. Even an empty string is a valid key/tub name. But for better performance the max key size defaults to 255 characters.
 
 Please keep in mind that Canery uses strings for all keys/tub names, so any other data type will be converted to a string!
 

data/lib/canery/backend.rb

@@ -11,10 +11,18 @@ module Canery
     
     def initialize(connection_uri)
       raise ArgumentError, "connection_uri must be a String or nil" unless NilClass === connection_uri || String === connection_uri
+      
       @connection = connection_uri.nil? ? Sequel.sqlite : Sequel.connect(connection_uri)
       @namespace_cache = {}
     end
     
+    # Only expose call method    
+    def call(command, *args)
+      self.send(command, *args)
+    end
+    
+    private
+    
     # Basic namespace methods #
     ###########################
     
@@ -41,8 +49,8 @@ module Canery
     def namespace?(name)
       connection.table_exists?(basic_tub_name(name))
     end
-    
-    
+
+
     # Methods for get, set, etc. #
     ##############################
     
@@ -55,14 +63,14 @@ module Canery
       raise ArgumentError, "keys argument must be an Array of keys" unless Array === keys
       keys.map!{ |key| build_key(key) }
 
-      # Sort data in the order they appear in the 'keys' Array
+      # Sort the data in the order they appear in the 'keys' Array
       namespace(name).where(:key => keys).sort_by { |element| keys.index(element[:key]) }.map {|dataset| load(dataset[:value]) }
     end
     
     def set(name, key, value)
       begin
         namespace(name).insert(:key => build_key(key), :value => dump(value)) && build_key(key)
-      rescue Sequel::DatabaseError # raised if the key already exists, than update
+      rescue Sequel::DatabaseError # key already exists, use update instead
         update(name, key, value)
       rescue
         "ERROR"
@@ -74,7 +82,7 @@ module Canery
       begin
         namespace(name).multi_insert(data.map{ |key, value| {:key => build_key(key), :value => dump(value)} }) && "OK"
       rescue
-        # Fallback to the slower update method
+        # Fallback to the O(n) update method
         data.each do |key, value|
           update(name, key, value)
         end && "OK"
@@ -116,7 +124,7 @@ module Canery
       end
       
       unless limit.nil?
-        raise ArgumentError, "limit must be a positive Integer" unless Integer === limit
+        raise ArgumentError, "limit parameter must be an Integer" unless Integer === limit
         data = data.limit(limit)
       end
       data.map{ |dataset| dataset[:key] }
@@ -126,13 +134,12 @@ module Canery
       namespace(name).where(:key => build_key(old_key)).limit(1).update(:key => build_key(new_key)) && "OK"
     end
     
-    def length(name)
+    def count(name)
       namespace(name).count
     end
     
-    private
-    
-    # Sequel seems to have problems with escaping, so we use Base64 encoding/decoding as a simple work around
+    # Sequel seems to have problems with escaping, 
+    # therefore we use Base64 encoding/decoding as a simple work around
     def load(data)
       Marshal.load(Base64.urlsafe_decode64(data))
     end

data/lib/canery/client.rb

@@ -14,27 +14,29 @@ module Canery
     end
     
     def tub(name)
-      create_tub(tub_name(name)) unless tub?(tub_name(name))
+      build_tub_name!(name)
+      create_tub(name) unless tub?(name)
       begin
         @tub_cache ||= {}
-        @tub_cache[tub_name(name)] ||= Tub.new(backend, tub_name(name))
+        @tub_cache[name] ||= Tub.new(backend, name)
       rescue
         raise Canery::CaneryError, "This tub does not exist! You must create it before you can use it."
       end
     end
     
     def delete_tub(name)
-      @tub_cache.delete(tub_name(name)) if @tub_cache[tub_name(name)]
-      backend.delete_namespace(tub_name(name))
+      build_tub_name!(name)
+      @tub_cache.delete(name) if @tub_cache[name]
+      backend.call(:delete_namespace, name)
     end
     
     def has_tub?(name)
-      backend.namespace?(tub_name(name))
+      backend.call(:namespace?, name)
     end
     alias :tub? :has_tub?
     
     def tubs
-      backend.namespaces
+      backend.call(:namespaces)
     end
           
     private
@@ -45,14 +47,14 @@ module Canery
     
     def create_tub(name)
       begin
-        backend.create_namespace(tub_name(name))
+        backend.call(:create_namespace, name)
       rescue => exception
         raise Canery::CaneryError, exception
       end
     end
     
-    def tub_name(name)
-      name.to_s.strip
+    def build_tub_name!(name)
+      name.to_s.strip!
     end
     
   end

data/lib/canery/tub.rb

@@ -14,60 +14,61 @@ module Canery
     end
     
     def get(key)
-      backend.get(name, key)
+      backend.call(:get, name, key)
     end
     alias :[] :get
     
     def mget(keys)
-      backend.mget(name, keys)
+      backend.call(:mget, name, keys)
     end
     
     def set(key, value)
-      backend.set(name, key || uuid, value)
+      backend.call(:set, name, key || uuid, value)
     end
     alias :[]= :set
     
     def mset(data)
-      backend.mset(name, data)
+      backend.call(:mset, name, data)
     end
     
     def delete(key)
-      backend.delete(name, key)
+      backend.call(:delete, name, key)
     end
     
     def clear
-      backend.clear(name)
+      backend.call(:clear, name)
     end
     
     def has_key?(key)
-      backend.has_key?(name, key)
+      backend.call(:has_key?, name, key)
     end
     alias :key? :has_key?
     
     def keys
-      backend.keys(name)
+      backend.call(:keys, name)
     end
     
     def values
-      backend.values(name)
+      backend.call(:values, name)
     end
     
     def sort(order, limit = nil)
       begin
-        backend.sort(name, order, limit)
-      rescue ArgumentError
-        raise Canery::CaneryError, "limit parameter must be an Integer"
+        backend.call(:sort, name, order, limit)
+      rescue ArgumentError => e
+        raise Canery::CaneryError, e
       end
     end
     
     def rename(old_key, new_key)
-      backend.rename(name, old_key, new_key)
+      backend.call(:rename, name, old_key, new_key)
     end
     
     def length
-      backend.length(name)
+      backend.call(:count, name)
     end
     alias :size :length
+    alias :count :length    
     
     private
     

data/lib/canery/version.rb

@@ -1,5 +1,5 @@
 # encoding: utf-8
 
 module Canery
-  VERSION = "0.1.3"
+  VERSION = "0.1.4"
 end

data/spec/canery_tub_spec.rb

@@ -73,6 +73,15 @@ describe Canery::Tub do
           store.get(key).should == value
         end
       end
+      
+      it "should overwrite alread set values" do
+        store = @client.tub("store")
+        store.mset(demo_hash).should == "OK"
+        store.mset(second_demo_hash).should == "OK"
+        second_demo_hash.each do |key, value|
+          store.get(key).should == value
+        end
+      end
     end
   end
   

data/spec/spec_helper.rb

@@ -6,4 +6,8 @@ end
 
 def demo_hash
   {"homer" => "Homer Simpson", "marge" => "Marge Simpson", "lisa" => "Lisa Simpson", "bart" => "Bart Simpson", "maggy" => "Maggy Simpson"}
+end
+
+def second_demo_hash
+  {"homer" => "Simpson Homer", "marge" => "Simpson Marge", "lisa" => "Simpson Lisa", "bart" => "Simpson Bart", "maggy" => "Simpson Maggy"}
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: canery
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.1.4
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-08-25 00:00:00.000000000 Z
+date: 2012-08-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sequel
@@ -94,7 +94,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -281279343697412722
+      hash: -3305371081524146636
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -103,7 +103,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -281279343697412722
+      hash: -3305371081524146636
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.24