cachew 0.1.1 → 0.2.0

data/.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

data/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

data/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

data/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]

data/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

data/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

data/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

data/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

data/lib/cachew/null.rb

@@ -0,0 +1,28 @@
+require "cachew/adapter"
+
+module Cachew
+  # Null version of Cachew. Never caches anything, and returns value of given
+  # block directly.
+  class Null < Adapter
+    class << self
+      # Returns singleton instance of Null adapter.
+      # @return [Null]
+      def new
+        @instance ||= super
+      end
+    end
+
+    private
+
+    # :nodoc:
+    def __get__(*)
+      UNDEFINED
+    end
+
+    # :nodoc:
+    def __set__(*) end
+
+    # :nodoc:
+    def __key__(*) end
+  end
+end

data/lib/cachew/version.rb

@@ -1,3 +1,4 @@
-class Cachew
-  VERSION = "0.1.1"
+module Cachew
+  # Cachew version
+  VERSION = "0.2.0"
 end

data/spec/lib/cachew/hash_spec.rb

@@ -0,0 +1,75 @@
+require "spec_helper"
+
+RSpec.describe Cachew::Hash do
+  describe ".new" do
+    it "accepts any #to_hash object" do
+      storage = double(:to_hash => {})
+
+      described_class.new(storage).fetch(:foo) { :bar }
+
+      expect(storage.to_hash).not_to be_empty
+    end
+
+    it "tolerates argument-less call" do
+      expect { described_class.new }.not_to raise_error
+    end
+  end
+
+  describe "#[]" do
+    let(:cachew) { described_class.new }
+
+    context "when value is not cahed yet" do
+      it "evaluates given block" do
+        expect { |b| cachew.fetch :foo, &b }.to yield_control
+      end
+
+      it "returns evaluated value" do
+        expect(cachew.fetch(:foo) { :bar }).to be :bar
+      end
+    end
+
+    context "when value was already cached" do
+      before { cachew.fetch(:foo) { :cached } }
+
+      it "does not evaluates block" do
+        expect { |b| cachew.fetch(:foo, &b) }.not_to yield_control
+      end
+
+      it "returns previously cached value" do
+        expect(cachew.fetch(:foo) { :bar }).to be :cached
+      end
+    end
+
+    context "when value with expiration still fresh" do
+      before { cachew.fetch(:foo, :ttl => 84) { :cached } }
+
+      it "does not evaluates given block" do
+        Timecop.travel 42 do
+          expect { |b| cachew.fetch :foo, :ttl => 84, &b }.not_to yield_control
+        end
+      end
+
+      it "returns previously cached value" do
+        Timecop.travel 42 do
+          expect(cachew.fetch(:foo, :ttl => 84) { :bar }).to be :cached
+        end
+      end
+    end
+
+    context "when value with expiration became stale" do
+      before { cachew.fetch(:foo, :ttl => 21) { :cached } }
+
+      it "evaluates given block" do
+        Timecop.travel 42 do
+          expect { |b| cachew.fetch :foo, :ttl => 21, &b }.to yield_control
+        end
+      end
+
+      it "returns evaluated value" do
+        Timecop.travel 42 do
+          expect(cachew.fetch(:foo, :ttl => 21) { :bar }).to be :bar
+        end
+      end
+    end
+  end
+end

data/spec/lib/cachew/null_spec.rb

@@ -0,0 +1,23 @@
+require "spec_helper"
+
+RSpec.describe Cachew::Null do
+  let(:cachew) { described_class.new }
+
+  describe ".new" do
+    it "returns Singleton instance" do
+      expect(cachew).to be described_class.new
+    end
+  end
+
+  describe "#[]" do
+    it "always evaluates given block" do
+      expect { |b| cachew.fetch(:foo, &b) }.to yield_control
+    end
+
+    it "returns value of given block" do
+      [:foo, :bar, :baz].each do |val|
+        expect(cachew.fetch(:foo) { val }).to be val
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -1,23 +1,20 @@
 require "simplecov"
 require "coveralls"
-
+require "timecop"
 
 SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
   SimpleCov::Formatter::HTMLFormatter,
   Coveralls::SimpleCov::Formatter
 ]
 
-
 SimpleCov.start do
   add_filter "/spec/"
 end
 
+Timecop.safe_mode = true
 
 require "cachew"
 
-
 RSpec.configure do |config|
-  config.expect_with :rspec do |c|
-    c.syntax = :expect
-  end
+  config.disable_monkey_patching!
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cachew
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-02-03 00:00:00.000000000 Z
+date: 2014-07-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -18,7 +18,7 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '1.5'
+        version: '1.6'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -26,7 +26,7 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '1.5'
+        version: '1.6'
 description: Unified cache interface.
 email:
 - ixti@member.fsf.org
@@ -44,15 +44,12 @@ files:
 - Rakefile
 - cachew.gemspec
 - lib/cachew.rb
-- lib/cachew/adapters.rb
-- lib/cachew/adapters/base_adapter.rb
-- lib/cachew/adapters/hash_adapter.rb
-- lib/cachew/adapters/null_adapter.rb
+- lib/cachew/adapter.rb
+- lib/cachew/hash.rb
+- lib/cachew/null.rb
 - lib/cachew/version.rb
-- spec/lib/cachew/adapters/hash_adapter_spec.rb
-- spec/lib/cachew/adapters/null_adapter_spec.rb
-- spec/lib/cachew/adapters_spec.rb
-- spec/lib/cachew_spec.rb
+- spec/lib/cachew/hash_spec.rb
+- spec/lib/cachew/null_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/ixti/cachew
 licenses:
@@ -69,7 +66,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 797334216198397338
+      hash: 4155366000220806670
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -78,16 +75,14 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 797334216198397338
+      hash: 4155366000220806670
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.23
+rubygems_version: 1.8.23.2
 signing_key: 
 specification_version: 3
-summary: cachew-0.1.1
+summary: cachew-0.2.0
 test_files:
-- spec/lib/cachew/adapters/hash_adapter_spec.rb
-- spec/lib/cachew/adapters/null_adapter_spec.rb
-- spec/lib/cachew/adapters_spec.rb
-- spec/lib/cachew_spec.rb
+- spec/lib/cachew/hash_spec.rb
+- spec/lib/cachew/null_spec.rb
 - spec/spec_helper.rb

data/lib/cachew/adapters.rb

@@ -1,16 +0,0 @@
-require "cachew/adapters/base_adapter"
-require "cachew/adapters/hash_adapter"
-require "cachew/adapters/null_adapter"
-
-class Cachew
-  module Adapters
-    def self.build_adapter_for(store)
-      case store
-      when BaseAdapter  then store
-      when Cachew       then store.adapter
-      when Hash         then HashAdapter.new(store)
-      else                   NullAdapter.new
-      end
-    end
-  end
-end

data/lib/cachew/adapters/base_adapter.rb

@@ -1,5 +0,0 @@
-class Cachew
-  module Adapters
-    BaseAdapter = Struct.new(:store)
-  end
-end

data/lib/cachew/adapters/hash_adapter.rb

@@ -1,17 +0,0 @@
-class Cachew
-  module Adapters
-    class HashAdapter < BaseAdapter
-      def set(key, value)
-        store[key] = value
-      end
-
-      def get(key)
-        store[key]
-      end
-
-      def has?(key)
-        store.key?(key)
-      end
-    end
-  end
-end

data/lib/cachew/adapters/null_adapter.rb

@@ -1,17 +0,0 @@
-class Cachew
-  module Adapters
-    class NullAdapter < BaseAdapter
-      def set(_, value)
-        value
-      end
-
-      def get(_)
-        nil
-      end
-
-      def has?(_)
-        false
-      end
-    end
-  end
-end

data/spec/lib/cachew/adapters/hash_adapter_spec.rb

@@ -1,34 +0,0 @@
-require "spec_helper"
-
-describe Cachew::Adapters::HashAdapter do
-  let(:adapter) { described_class.new({}) }
-
-  describe "#set" do
-    it "returns back given value" do
-      expect(adapter.set(:foo, :bar)).to be :bar
-    end
-
-    it "sets value in the underlying store Hash" do
-      adapter.set(:foo, :bar)
-      expect(adapter.store).to eq :foo => :bar
-    end
-  end
-
-  describe "#get" do
-    it "returns nil if value does not exists" do
-      expect(adapter.get(:foo)).to be_nil
-    end
-
-    it "returns saved value if exists" do
-      adapter.store[:foo] = :bar
-      expect(adapter.get(:foo)).to be :bar
-    end
-  end
-
-  describe "#has?" do
-    it "returns true even if stored value is nil" do
-      adapter.store[:foo] = nil
-      expect(adapter.has?(:foo)).to be_true
-    end
-  end
-end

data/spec/lib/cachew/adapters/null_adapter_spec.rb

@@ -1,25 +0,0 @@
-require "spec_helper"
-
-describe Cachew::Adapters::NullAdapter do
-  let(:adapter) { described_class.new }
-
-  describe "#set" do
-    it "returns back given value" do
-      expect(adapter.set(:foo, :bar)).to be :bar
-    end
-  end
-
-  describe "#get" do
-    it "always returns nil" do
-      adapter.set(:foo, :bar)
-      expect(adapter.get :foo).to be_nil
-    end
-  end
-
-  describe "#has?" do
-    it "always returns false" do
-      adapter.set(:foo, :bar)
-      expect(adapter.has? :foo).to be_false
-    end
-  end
-end

data/spec/lib/cachew/adapters_spec.rb

@@ -1,31 +0,0 @@
-require "spec_helper"
-
-describe Cachew::Adapters do
-  describe ".build_adapter_for" do
-    context "with Hash instance" do
-      it "returns HashAdapter" do
-        adapter = described_class.build_adapter_for :foo => :bar
-        expect(adapter).to be_a Cachew::Adapters::HashAdapter
-      end
-    end
-
-    context "with instance of BaseAdapter" do
-      it "returns adapter as is" do
-        adapter = Cachew::Adapters::HashAdapter.new :foo => :bar
-        expect(described_class.build_adapter_for adapter).to be adapter
-      end
-    end
-
-    context "with instance of Cachew" do
-      it "returns original #adapter" do
-        original = Cachew.new :foo => :bar
-        expect(Cachew.new(original).adapter).to be original.adapter
-      end
-    end
-
-    it "returns NullAdapter if can't find better candidate" do
-      expect(described_class.build_adapter_for "test")
-        .to be_a Cachew::Adapters::NullAdapter
-    end
-  end
-end

data/spec/lib/cachew_spec.rb

@@ -1,53 +0,0 @@
-require "spec_helper"
-
-describe Cachew do
-  describe ".new" do
-    it "initiates with NullAdapter by default" do
-      expect(described_class.new.adapter).to be_a Cachew::Adapters::BaseAdapter
-    end
-
-    it "calls Adapters.build_adapter_for with given store" do
-      store = { :foo => :bar }
-      expect(Cachew::Adapters).to receive(:build_adapter_for).with store
-      described_class.new store
-    end
-  end
-
-  describe "#set" do
-    subject(:cachew) { described_class.new.set }
-    specify { expect { cachew.adapter.to receive :set } }
-  end
-
-  describe "#get" do
-    subject(:cachew) { described_class.new.get }
-    specify { expect { cachew.adapter.to receive :get } }
-  end
-
-  describe "#has?" do
-    subject(:cachew) { described_class.new.has? }
-    specify { expect { cachew.adapter.to receive :has? } }
-  end
-
-  describe "#fetch" do
-    let(:cachew) { described_class.new :foo => :bar }
-
-    it "calls has?" do
-      expect(cachew).to receive(:has?)
-      cachew.fetch(:foo) { :moo }
-    end
-
-    context "when adapter has? key" do
-      it "calls get" do
-        expect(cachew).to receive(:get)
-        cachew.fetch(:foo) { :moo }
-      end
-    end
-
-    context "when adapter does not has? key" do
-      it "calls set" do
-        expect(cachew).to receive(:set)
-        cachew.fetch(:bar) { :moo }
-      end
-    end
-  end
-end