duality 0.0.4 → 0.0.5

data/Gemfile

@@ -1,5 +1,9 @@
 source :rubygems
 
+group :test, :development do
+  gem 'rake'
+end
+
 group :test do
   gem 'rspec'
   gem 'simplecov'
@@ -8,6 +12,7 @@ group :test do
 end
 
 group :development do
-  gem 'rdoc'
+  gem 'yard'
+  gem 'redcarpet'
 end
 

data/HISTORY.md

@@ -1,5 +1,9 @@
 # Duality
 
+## v0.0.5
+
+* added flush_expired support
+
 ## v0.0.4
 
 * removed threading as it's proved to be slower

data/README.md

@@ -1,24 +1,78 @@
-duality
-=======
+### Duality
 
-a simple cache interface to setting and getting from two caches
+[Duality](http://github.com/rubyops/duality) is a simple cache helper for using multiple caches. The idea is that you have local cache and a shared cache -- or fast and slow cache -- and want to save to both, and read from local, if present and shared if not. The idea came from [Hector Virgen](http://www.virgentech.com/) (the PHP Zend Jedi Ninja Badass) and [Zend_Cache_Backend_TwoLevels](http://framework.zend.com/manual/en/zend.cache.backends.html#zend.cache.backends.twolevels), which does basically the same thing in PHP.
 
-* sets to both caches asynchronously
-* gets from faster and then fails over to slower
+A few things to note:
 
-## Usage
+* It currently implements the methods of my other two cache projects -- [Diskcached](/tag/diskcached) and [Monogocached](/tag/mongocached), both which take their implementation from the popular [Memcached](https://rubygems.org/gems/memcached).
+* I'm working on a Rails implementation, which uses [ActiveSupport::Cache::Store](http://api.rubyonrails.org/classes/ActiveSupport/Cache/Store.html) -- more to come on that later.
+* My origional intent was to make sets asynchronous, but benchmarking shows that to be less efficent due either to my lack of knowledge in threaded development, or -- based on what I'm reading -- ruby inefficenies in threading.
 
-        require 'diskcached'
-        require 'memcached'
-        require 'duality'
-        
-        $cache = Duality.new(Diskcached.new, Memcached.new("remotehost:11211")) # example caches
-        $cache.set('key', "content")
-        puts $cache.get('key')
-        
-## More Info
 
-### [Documentation](http://rubyops.github.com/duality/doc/Duality.html) 
-### [Coverage](http://rubyops.github.com/duality/coverage/)
+### Installation
 
+        gem install duality 
+	
+Or via bundler:
+
+	# file: Gemfile
+	source :rubygems
+	gem 'duality'
+	
+
+### Basic Usage
+
+	require 'diskcached'
+	require 'mongocached' # or memcached if you prefer
+	require 'duality'
+	
+	$cache = Dulatiy.new(Diskcached.new, Mongocached.new( host: 'remotehost' ))
+	
+	# cache something
+	$cache.set('cache_key', 'cache_content')
+	
+	# get cache
+	puts $cache.get('cache_key') # => cache_content
+	
+	# delete something
+	$cache.delete('cache_key')
+	
+	# flush cache
+	$cache.flush
+	
+### Unimplemented Cache Methods
+
+One thing Duality does for compatability is pass methods via #method_missing. This allows for you to access any method your cache might implement, even if Duality doesn't itself implement it. 
+
+It's important to note, though, that the this implementation does not take advantage of the get methods speed increase by returning the faster cache first, but will perform the action in a serialized fashion on one cache, then the other. Additionally, by default, it will return the value of whichever cache works, meaning that if one raises and exception, returns false or nil, but the other returns successfully, it will return the successful result. This is by design.
+
+To force both caches to "be good or die", I've implemented **strict calls**, where by you can prepend "strict_" to any method call which you know Duality doesn't implement and force it to fail if both caches don't return a valid result.
+
+Another thing that's worth mentioning is if either cache raise an exception, it will be caught. If both caches raise an exception, *nil* will be returned. Also, if both caches return *nil*, *nil* will be returned.
+
+##### Example
+
+	# when only one cache contains requested method
+	
+	$cache.one_only_method('cache_key') 
+	# => returns implementing caches return value
+	
+	$cache.strict_one_only_method('cache_key') 
+	# => raises no method exception
+	
+	#
+	# when both caches contains requested method
+	
+	$cache.both_only_method('cache_key')
+	# => returns best match
+	
+	$cache.strict_both_only_method('cache_key')
+	# => returns best match
+
+
+### More Info
+
+#### [Documentation](http://rubyops.github.com/duality/doc/Duality.html) 
+#### [Coverage](http://rubyops.github.com/duality/coverage/)
+#### [Benchmarks](https://github.com/rubyops/duality/blob/master/BENCHMARK.md)
 

data/lib/duality.rb

@@ -1,6 +1,6 @@
 class Duality
 
-  VERSION = "0.0.4"
+  VERSION = "0.0.5"
   @@fast, @@slow = nil
 
   def initialize fast, slow
@@ -31,6 +31,11 @@ class Duality
   end
   alias :clean :flush
 
+  def flush_expired
+    run_method(:flush_expired)
+  end
+  alias :cleanup :flush_expired
+
   # Get from fast or slow.
   # - returns nil if none are found
   def get key

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: duality
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.0.5
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-07-20 00:00:00.000000000 Z
+date: 2012-07-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -114,6 +114,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
+      segments:
+      - 0
+      hash: -4385882492458754617
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -125,6 +128,6 @@ rubyforge_project:
 rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
-summary: Simple disk cache
+summary: two caches are better then one
 test_files: []
 has_rdoc: