traveladapter 0.0.1

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+.bundle
+.config
+coverage
+InstalledFiles
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+
+# YARD artifacts
+.yardoc
+_yardoc
+doc/

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in traveladapter.gemspec
+gemspec

data/README.md

@@ -0,0 +1,4 @@
+traveladapter
+=============
+
+Wrapper around key-value stores used for caching.

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require "rake"
+require "rake/testtask"
+
+task :default => [ :unittests ]
+
+Rake::TestTask.new("unittests") do |t|
+  t.pattern = "test/*_test.rb"
+  t.verbose = true
+end

data/lib/traveladapter.rb

@@ -0,0 +1,2 @@
+require "traveladapter/version"
+require "traveladapter/adapter"

data/lib/traveladapter/adapter.rb

@@ -0,0 +1,216 @@
+require 'thread'
+
+module TravelAdapter
+
+  # Versatile wrapper around key-value stores, providing abstraction
+  # and expiration facility.
+  class Adapter
+    
+    # Create a new instance of TravelAdapter::Adapter object.
+    #
+    # If no object is passed, the Adapter will internally use a Hash.
+    #
+    # @param [Object] store Underlying key-value store (eg. Hash, Redis,
+    #   LevelDB etc.)
+    def initialize(store=nil)
+      @semaphore = Mutex::new
+      if store.nil?
+        @store = Hash::new
+      else
+        @store = store
+      end
+    end
+
+    # Decrement a counter stored under a particular key. A counter can be
+    # any numeric object, as long as it responds sensibly to + and -
+    # messages.
+    #
+    # @param [String] key Key used to find a counter object.
+    # @return [Numeric] Counter value after decrementing.
+    def decrement(key)
+      change_by(key, -1)
+    end
+
+    # Delete a key-value pair stored with a particular key.
+    #
+    # @param [String] key Key used to find a counter object.
+    # @return [Boolean] true if the operation succeeds, false if not
+    def delete(key)
+      begin
+        @semaphore.synchronize do
+          atomic_delete(key)
+          atomic_delete(marshal_key(key))
+          atomic_delete(expiration_key(key))
+        end
+        return true
+      rescue Exception
+        return false
+      end
+    end
+
+    # Get the value stored with a particular key.
+    #
+    # @param [String] key Key used to find the value.
+    # @return [Object] object stored with a given key. Returns nil if the
+    #   object is not found or the key has expired.
+    def get(key)
+      return nil unless atomic_has_key?(key)
+      if expired?(key)
+        delete(key)
+        return nil
+      elsif needs_marshaling?(key)
+        return Marshal::load(atomic_get(key))
+      else
+        return atomic_get(key)
+      end
+    end
+
+    # Check if anything is stored with a particular key.
+    #
+    # @param [String] key Key used to find a counter object.
+    # @return [Boolean] true if the key is not expired and associated with
+    # a value, otherwise false.
+    def has_key?(key)
+      !get(key).nil?
+    end
+
+    # Increment a counter stored under a particular key. A counter can be
+    # any numeric object, as long as it responds sensibly to + and -
+    # messages.
+    #
+    # @param [String] key Key used to find a counter object.
+    # @return [Numeric] Counter value after incrementing.
+    def increment(key)
+      change_by(key, 1)
+    end
+
+    # Get non-expired keys stored.
+    #
+    # @param [Regexp] pattern Regular expression used to filter out keys.
+    # @return [Array] Non-expired keys matching the given pattern.
+    def keys(pattern=/.*/)
+      re = /\A__(expire|marshal)__:/
+      return atomic_keys.select do |k|
+        k.match(re).nil? and not expired?(k) and !k.match(pattern).nil?
+      end
+    end
+
+    # Set the value stored with a particular key.
+    #
+    # @param [String] key Key used to for the object.
+    # @param [String] value Value for the key.
+    # @param [Integer] ttl Time (in seconds) to keep the value.
+    # @return [Object] object stored.
+    def set(key, value, ttl=(10 << 32))
+      @semaphore.synchronize do
+        if value.is_a?(String)
+          atomic_set(marshal_key(key), "0")
+        else
+          atomic_set(marshal_key(key), "1")
+          value = Marshal::dump(value)
+        end
+        atomic_set(key, value)
+        set_ttl(key, ttl)
+      end
+      return value
+    end
+
+    # Change how long the value is to be stored.
+    #
+    # @param [String] key Key used to for the object.
+    # @param [Integer] ttl Time from now (in seconds) to keep the value.
+    # @return [Time] Time when the key expires.
+    def set_ttl(key, ttl)
+      new_ttl = Time::now.to_i + ttl
+      atomic_set(expiration_key(key), new_ttl.to_s)
+      return Time::at(new_ttl)
+    end
+
+    # Get expiration time.
+    #
+    # @param [String] key Key used to for the object.
+    # @return [Integer] Number of seconds until object expiration
+    def get_ttl(key)
+      expires = atomic_get(expiration_key(key))
+      return expires.nil? ? nil : (expires.to_i - Time::now.to_i)
+    end
+
+    private
+
+    def atomic_has_key?(key)
+      !atomic_get(key).nil?
+    end
+
+    def atomic_delete(key)
+      if @store.respond_to?(:delete)
+        @store.delete(key)
+      elsif @store.respond_to?(:del)
+        @store.del(key)
+      else
+        @store.atomic_set(key, nil)
+      end
+    end
+
+    def atomic_get(key)
+      if @store.respond_to?(:fetch)
+        begin
+          return @store.fetch(key)
+        rescue KeyError
+          return nil
+        end
+      elsif @store.respond_to?(:get)
+        return @store.get(key)
+      else
+        return @store[key]
+      end
+    end
+
+    def atomic_keys
+      @store.keys
+    end
+
+    def atomic_set(key, value)
+      if @store.respond_to?(:set)
+        @store.set(key, value)
+      elsif @store.respond_to?(:put)
+        @store.put(key, value)
+      else
+        @store[key] = value
+      end
+    end
+
+    def change_by(key, value)
+      @semaphore.synchronize do
+        current_value = atomic_get(key)
+        unless expired?(key)
+          new_value = Marshal::load(current_value) + value
+          atomic_set(key, Marshal::dump(new_value))
+          return new_value
+        else
+          return false
+        end
+      end
+    end
+
+    def expiration_key(key)
+      sprintf('__expire__:%s', key)
+    end
+
+    def marshal_key(key)
+      sprintf('__marshal__:%s', key)
+    end
+
+    def expired?(key)
+      get_ttl(key) <= 0
+    end
+
+    def needs_marshaling?(key)
+      atomic_get(marshal_key(key)) == "1"
+    end
+
+    alias :[]  :get
+    alias :[]= :set
+
+  end
+
+end

data/lib/traveladapter/version.rb

@@ -0,0 +1,3 @@
+module TravelAdapter
+  VERSION = "0.0.1"
+end

data/test/traveladapter_test.rb

@@ -0,0 +1,98 @@
+require "test/unit"
+require "mocha"
+require "pry"
+
+require "traveladapter"
+
+Person = Struct::new(:name, :age)
+
+class TravelAdapterTest < Test::Unit::TestCase
+  
+  def setup
+    @h_adapter = TravelAdapter::Adapter::new
+  end
+  
+  def test_set_and_get_without_ttl
+    @h_adapter.set("chunky", "bacon")
+    assert_equal @h_adapter.get("chunky"), "bacon", "Wrong key has been set"
+    assert_equal @h_adapter.keys, ["chunky"], "Unexpected set of keys"
+  end
+  
+  def test_aliased_set_and_get_without_ttl
+    @h_adapter["chunky"] = "bacon"
+    assert_equal @h_adapter["chunky"], "bacon", "Wrong key has been set"
+    assert_equal @h_adapter.keys, ["chunky"], "Unexpected set of keys"
+  end
+  
+  def test_with_miss
+    assert @h_adapter["chunky"].nil?, "Did not expected to find anything"
+  end
+  
+  def test_with_marshaling
+    @h_adapter["p"] = Person::new("John Smith", 29)
+    p = @h_adapter["p"]
+    assert p.is_a?(Person), "Expected a Person object"
+    assert p.name.is_a?(String), "Expected a String object"
+    assert p.age.is_a?(Fixnum), "Expected a Fixnum object"
+    assert_equal @h_adapter.keys, ["p"], "Unexpected set of keys"
+  end
+  
+  def test_set_and_get_with_ttl
+    Time::expects(:now).times(3).returns(*%w(0 3 6))
+    @h_adapter.set("chunky", "bacon", 5)
+    assert_equal @h_adapter.get("chunky"), "bacon", "Unexpected value"
+    assert @h_adapter.get("chunky").nil?, "Expected the key to expire"
+  end
+  
+  def test_keys_without_pattern_or_ttl
+    @h_adapter.set("hello", "world")
+    @h_adapter.set("chunky", "bacon")
+    assert @h_adapter.keys.include?("hello")
+    assert @h_adapter.keys.include?("chunky")
+  end
+  
+  def test_keys_with_pattern
+    @h_adapter.set("hello", "world")
+    @h_adapter.set("chunky", "bacon")
+    assert @h_adapter.keys(/el/).include?("hello")
+    assert !@h_adapter.keys(/el/).include?("chunky")
+  end
+  
+  def test_keys_with_ttl
+    Time::expects(:now).times(6).returns(*%w(0 0 4 4 6 6))
+    @h_adapter.set("hello", "world", 5)
+    @h_adapter.set("chunky", "bacon", 10)
+    keys_at_4 = @h_adapter.keys
+    assert keys_at_4.include?("hello")
+    assert keys_at_4.include?("chunky")
+    keys_at_6 = @h_adapter.keys
+    assert !keys_at_6.include?("hello")
+    assert keys_at_6.include?("chunky")
+  end
+  
+  def test_get_ttl
+    Time::expects(:now).times(2).returns(*%w(0 2))
+    @h_adapter.set("chunky", "bacon", 10)
+    assert_equal @h_adapter.get_ttl("chunky"), 8, "Unexpected TTL"
+  end
+  
+  def test_get_ttl_for_a_nonexistent_key
+    assert @h_adapter.get_ttl("chunky").nil?, "Unexpected TTL"
+  end
+  
+  def test_delete
+    @h_adapter["chunky"] = "bacon"
+    assert @h_adapter.has_key?("chunky"), "Key expected but not found"
+    @h_adapter.delete("chunky")
+    assert !@h_adapter.has_key?("chunky"), "Key not expected but found"
+  end
+  
+  def test_increment_and_decrement
+    @h_adapter["counter"] = 0
+    assert_equal @h_adapter.increment("counter"), 1, "Expected the counter to be 1"
+    assert_equal @h_adapter.get("counter"), 1, "Expected the counter to be 1"
+    assert_equal @h_adapter.decrement("counter"), 0, "Expected the counter to be 0"
+    assert_equal @h_adapter.get("counter"), 0, "Expected the counter to be 0"
+  end
+  
+end

data/traveladapter.gemspec

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "traveladapter/version"
+
+Gem::Specification.new do |s|
+  s.name        = "traveladapter"
+  s.version     = TravelAdapter::VERSION
+  s.authors     = ["Marcin Wyszynski"]
+  s.email       = ["marcin.pixie@gmail.com"]
+  s.homepage    = ""
+  s.summary     = %q{Wrapper around key-value stores used for caching.}
+  s.description = %q{Wrapper around key-value stores used for caching.}
+
+  s.rubyforge_project = "traveladapter"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_dependency("rake")
+  s.add_development_dependency("mocha")
+
+end

metadata

@@ -0,0 +1,84 @@
+--- !ruby/object:Gem::Specification 
+name: traveladapter
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Marcin Wyszynski
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-07-29 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rake
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: mocha
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id002
+description: Wrapper around key-value stores used for caching.
+email: 
+- marcin.pixie@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- README.md
+- Rakefile
+- lib/traveladapter.rb
+- lib/traveladapter/adapter.rb
+- lib/traveladapter/version.rb
+- test/traveladapter_test.rb
+- traveladapter.gemspec
+homepage: ""
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+requirements: []
+
+rubyforge_project: traveladapter
+rubygems_version: 1.8.15
+signing_key: 
+specification_version: 3
+summary: Wrapper around key-value stores used for caching.
+test_files: 
+- test/traveladapter_test.rb