Release v0.2.0

Complete API re-write.

.rubocop.yml

@@ -14,23 +14,61 @@ ClassLength:
 CyclomaticComplexity:
   Max: 6
 
+EmptyLineBetweenDefs:
+  AllowAdjacentOneLineDefs: true
+
 BlockNesting:
   Max: 3
 
 HashSyntax:
   EnforcedStyle: hash_rockets
 
-Encoding:
-  Enabled: false
-
 StringLiterals:
   EnforcedStyle: double_quotes
 
+AlignParameters:
+  EnforcedStyle: with_fixed_indentation
+
+IndentHash:
+  EnforcedStyle: consistent
+
+PercentLiteralDelimiters:
+  PreferredDelimiters:
+    '%':  ()
+    '%i': ()
+    '%q': ()
+    '%Q': ()
+    '%r': '{}'
+    '%s': ()
+    '%w': '[]'
+    '%W': '[]'
+    '%x': ()
+
+Encoding:
+  Enabled: false
+
 BracesAroundHashParameters:
   Enabled: false
 
 Documentation:
   Enabled: false
 
-EmptyLines:
+# Not all trivial readers/writers can be defined with attr_* methods
+TrivialAccessors:
+  Enabled: false
+
+# New lambda syntax is UGLY, don't enforce it
+Lambda:
   Enabled: false
+
+# Ridiculous (and IMHO useless) restriction, that makes impossible aligning
+# code like this:
+#
+#   redis.hset    :k1, now
+#   redis.hincrby :k2, 123
+SingleSpaceBeforeFirstArg:
+  Enabled: false
+
+AllCops:
+  Include:
+    - Gemfile

Gemfile

@@ -1,17 +1,20 @@
-source 'https://rubygems.org'
+source "https://rubygems.org"
+
+platforms :ruby_19, :ruby_20, :ruby_21 do
+  group :development do
+    gem "celluloid-io"
+    gem "guard-rspec"
+  end
+
+  gem "rubocop"
+end
 
 gem "rake"
-gem "rspec"
-gem "guard-rspec"
-gem "rubocop"
+gem "rspec", "~> 3.0"
+gem "timecop"
+
 gem "coveralls", :require => false
 gem "simplecov", :require => false
 
-platforms :rbx do
-  gem "racc"
-  gem "rubinius-coverage", "~> 2.0"
-  gem "rubysl", "~> 2.0"
-end
-
 # Specify your gem's dependencies in cachew.gemspec
 gemspec

README.md

@@ -24,24 +24,57 @@ Or install it yourself as:
 ## Usage
 
 ``` ruby
-# With HashAdapter
-cache = Cachew.new({})
+# In-memory Hash
+cache = Cachew::Hash.new
 
-cache.has?(:foo)           # => false
-cache.fetch(:foo) { :bar } # => :bar
+cache.fetch(:foo) { Time.now.to_i } # => 1405724687
+cache.fetch(:foo) { Time.now.to_i } # => 1405724687
 
-cache.has?(:foo)           # => true
-cache.fetch(:foo) { :moo } # => :bar
+# With ttl
+cache.fetch(:foo, :ttl => 10) { Time.now.to_i } # => 1405724689
 
+# Before 10 seconds will expire
+cache.fetch(:foo, :ttl => 10) { Time.now.to_i } # => 1405724689
 
-# With (default) NullAdapter
-cache = Cachew.new
+# Once 10+ seconds pass
+cache.fetch(:foo, :ttl => 10) { Time.now.to_i } # => 1405724695
 
-cache.has?(:foo)           # => false
-cache.fetch(:foo) { :bar } # => :bar
+# Withot cache (think of it as NullLogger)
+cache = Cachew::Null.new
 
-cache.has?(:foo)           # => false
-cache.fetch(:foo) { :moo } # => :moo
+cache.fetch(:foo) { Time.now.to_i } # => 1405724687
+cache.fetch(:foo) { Time.now.to_i } # => 1405724688
+```
+
+You can easily write your own adapters:
+
+```
+class Cachew::Redis < Cache::Adapter
+  def initialize(client)
+    @client = client
+  end
+
+  private
+
+  def __set__(key, val, ttl)
+    val = Marshal.dump val
+
+    if 0 == ttl
+      @client.set key, val
+    else
+      @client.setex key, val, ttl
+    end
+  end
+
+  def __get__(key)
+    val = @client.get(key)
+    val ? Marshal.load(val) : UNDEFINED
+  end
+
+  def __key__(*)
+    "cachew:#{super}"
+  end
+end
 ```
 
 ## Contributing

Rakefile

@@ -1,9 +1,9 @@
 require "bundler/gem_tasks"
 
-require 'rspec/core/rake_task'
+require "rspec/core/rake_task"
 RSpec::Core::RakeTask.new
 
-require 'rubocop/rake_task'
-Rubocop::RakeTask.new
+require "rubocop/rake_task"
+RuboCop::RakeTask.new
 
 task :default => [:spec, :rubocop]

cachew.gemspec

@@ -18,5 +18,5 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
-  spec.add_development_dependency "bundler", "~> 1.5"
+  spec.add_development_dependency "bundler", "~> 1.6"
 end

lib/cachew.rb

@@ -1,19 +1,4 @@
+require "cachew/adapter"
+require "cachew/hash"
+require "cachew/null"
 require "cachew/version"
-require "cachew/adapters"
-
-# Unified cache interface
-class Cachew
-  extend Forwardable
-
-  attr_reader :adapter
-
-  def initialize(store = nil)
-    @adapter = Adapters.build_adapter_for store
-  end
-
-  def fetch(key)
-    has?(key) ? get(key) : set(key, yield)
-  end
-
-  def_delegators :adapter, :set, :get, :has?
-end

lib/cachew/adapter.rb

@@ -0,0 +1,78 @@
+require "digest/md5"
+require "json"
+
+module Cachew
+  # Base class for Cachew adapters.
+  #
+  # @example Building custom adapters
+  #
+  #     class Cachew::Redis < Cache::Adapter
+  #       def initialize(client)
+  #         @client = client
+  #       end
+  #
+  #       private
+  #
+  #       def __set__(key, val, ttl)
+  #         val = Marshal.dump val
+  #
+  #         if 0 == ttl
+  #           @client.set key, val
+  #         else
+  #           @client.setex key, val, ttl
+  #         end
+  #       end
+  #
+  #       def __get__(key)
+  #         val = @client.get(key)
+  #         val ? Marshal.load(val) : UNDEFINED
+  #       end
+  #
+  #       def __key__(*)
+  #         "cachew:#{super}"
+  #       end
+  #     end
+  #
+  class Adapter
+    # Internal constant used by `__get__` to notify that value is not in the
+    # cache or became stale
+    UNDEFINED = Object.new.freeze
+
+    # @example Usage
+    #
+    #   cachew.fetch "some_key", :ttl => 60 do
+    #     HTTP.get("http://example.com").to_s
+    #   end
+    #
+    def fetch(key, opts = {})
+      key = __key__ key, opts
+      val = __get__ key
+
+      if UNDEFINED.equal? val
+        val = yield
+        ttl = opts.fetch(:ttl) { 0 }.to_i
+
+        __set__ key, val, ttl
+      end
+
+      val
+    end
+
+    private
+
+    # :nodoc:
+    def __set__(_key, _val, _ttl)
+      fail "Not implemented"
+    end
+
+    # :nodoc:
+    def __get__(_key)
+      fail "Not implemented"
+    end
+
+    # :nodoc:
+    def __key__(*args)
+      Digest::MD5.hexdigest JSON.dump args
+    end
+  end
+end

lib/cachew/hash.rb

@@ -0,0 +1,25 @@
+require "cachew/adapter"
+
+module Cachew
+  # In-memory cache adapter.
+  class Hash < Adapter
+    # @param [#to_hash] store Underlying Hash used for storage
+    def initialize(store = {})
+      @store = store.to_hash
+    end
+
+    private
+
+    # :nodoc:
+    def __set__(key, val, ttl)
+      ttl = 0 >= ttl ? 0 : Time.now.to_i + ttl
+      @store[key] = [val, ttl]
+    end
+
+    # :nodoc:
+    def __get__(key)
+      val, ttl = @store[key]
+      ttl && (0 == ttl || ttl > Time.now.to_i) ? val : UNDEFINED
+    end
+  end
+end