nice_cache 0.1.0 → 0.2.0

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    ZjFlNDA4NmZhMmFmMDc0ZDZjNGQyNjJkMDVjY2M3ZjhkMjQ4NWFmOA==
+    NWNmMTQxOTZhNjE1YzQ2YWI5NjIyZGZlNjBkYTU0NjA3YjkwYWYxMQ==
   data.tar.gz: !binary |-
-    NGNkZDZhZmE5NmVhMGY4NTVkODQzMGIwYmVlN2E2ZjViNjY4NWY2Ng==
+    MTNkYzMwMGQ1MGVmZDU3YmZhYzc3MzNjYzY2MDE4ZmRjYjRlOGYyMg==
 SHA512:
   metadata.gz: !binary |-
-    NTY0ZTg0ZDAwN2YyNDcwY2Y1NWNhZjZkMTBjMzNiZmNmNmUyZWYyMDg3ODA4
-    Y2ExZWY1N2FlMGY3ZjE2ZjNhOGM0YTI2ZDhlMzkwYjdiYjVkMzdiMjFhZTYw
-    MWExMDBjMmJhYzQ4ZjBiYWNjYzJlZDNmOTU3NmEyNzgxMzZkM2U=
+    MGQwMTI2MWFlODFiZjllMDIzNzQwOTU4ZWRmN2VmYjFkMTQwMDIxYzc1ZGZl
+    MzM4ZTU3MjAyOGU5OTEwOWVkYWE3ZTcxOWVhYjJhNzI2MWM2YTRhMzk1ZDFk
+    MzEwNTk1NGM5ZmE3NGY4MTI2MDQ4NDBjYzc4MDhjN2ZkZmExY2E=
   data.tar.gz: !binary |-
-    OWE0ZGQ4MTJjYWE2Y2ZhN2QzYjVjYzE5MTE1MDk5OTY5OWVjNGUxODgzOGI2
-    ZWI5NDY1Zjk4ZmRlMDgyMjI4OTk5OTA1NzkwZmQ1YWE1ZWVlMDBiNmJhMmRj
-    ZmFiNmZiNzY3NWFmMTc0NzQ2YjQ1YjlhYzA5MjgzZjQ4MzJhM2Y=
+    YmU1MGIxODNiODAzNjFlMTFlY2NiY2ZjNzkyMmY3MjY5OWRmZTMwMjIwOTU2
+    N2ZmNzA2YjRjNjY5NzIxMTNmNGJiMTAzNTQwNDE4ZGFhMWZmNmJjYmNmYzlh
+    MTdlZWE1NzE0N2QxNmRmZjk5YmFjZmZmZmMzYjZkOGJiNjA2NDQ=

data/lib/nice_cache.rb

@@ -2,54 +2,87 @@ require 'redis-namespace'
 require_relative "nice_cache/fragment"
 require_relative "nice_cache/tag"
 
-module NiceCache
 
-  def self.config(&block)
-    block.call(self)
+class NiceCache
+  extend Forwardable
+  attr_accessor :redis, :tag_store
+
+  COMMANDS_WITH_TAGS = [
+    :set,
+    :setnx,
+    :hmset,
+    :hsetnx,
+    :lset,
+    :sadd,
+    :zadd,
+    # :mset,
+    # :msetnx,
+    # :zinterstore,
+    # :zunionstore
+  ]
+
+  def convert_tags(arg)
+    arg.respond_to?(:key) ? arg[:tags] : arg
   end
 
-  def self.redis
-    @redis ||= namespaced_redis
+  COMMANDS_WITH_TAGS.each do |method|
+    define_method method, ->(*args) do
+      if args.count > Redis.instance_method(method).arity
+        tags = convert_tags(args.pop)
+        key = args[0]
+        Fragment.new(self, key, tags)
+      end
+
+      redis.send(method, *args)
+    end
   end
 
-  def self.redis=(custom_redis)
-    @redis = namespaced_redis(custom_redis)
+  def del(fragment_name)
+    Fragment.find(self, fragment_name).delete
   end
 
-  def self.cache(data, tags)
-    tag_names = tags.is_a?(Hash) ? tags[:tags] : Array(tags)
-    Fragment.new(data, tag_names)
-    self
+  def destroy(key)
+    redis.del key
   end
 
-  def self.sweep_tags(*tag_names)
-    Tag.find(tag_names).map do |tag|
-      tag.sweep
-    end
+  def initialize(options = {})
+    @redis = options[:redis] || Redis.current
+    @tag_store = Redis::Namespace.new(:NiceCache, redis: redis)
   end
 
-  def self.sweep_fragments(*fragment_names)
-    fragment_names.map do |fragment_name|
-      Fragment.find(fragment_name).destroy
-    end
+  def method_missing(method, *args, &block)
+    return super unless redis.respond_to?(method)
+
+    self.class.send(:define_method, method, ->(*arguments) {
+      redis.send(method, *arguments, &block)
+    })
+
+    self.send(method, *args, &block)
   end
 
-  def self.all_fragments_key
-    "AllFragments"
+  def respond_to_missing?(method_name, include_private = false)
+    redis.respond_to?(method_name, include_private) || super
   end
 
-  def self.cleanup
-    fragments.map(&:destroy)
+  def sweep_tags(*tag_names)
+    Tag.find(self, tag_names).map do |tag|
+      tag.sweep
+    end
   end
 
-  def self.fragments
-    # O(N), N is number of fragment keys in NiceCache
-    redis.smembers(all_fragments_key).map { |name| Fragment.find(name) }
+  def flush_index!
+    #TODO: Benchmark
+    # all_fragments.map { |fragment| fragment.delete }
+    tag_store.keys.map { |key| tag_store.del key }
   end
 
-  private
-  def self.namespaced_redis(redis = nil)
-    redis ||= Redis.current
-    Redis::Namespace.new(:NiceCache, redis: redis)
+  def all_fragments
+    tag_store.smembers Fragment.all
   end
+
+  private
+
+  # def timestamp_key(time)
+  #   "Timestamp:#{time}"
+  # end
 end

data/lib/nice_cache/fragment.rb

@@ -1,95 +1,81 @@
-require_relative 'tag'
-
-module NiceCache
+class NiceCache
   class Fragment
-    attr_reader :name, :data
-
-    def self.find(name)
-      new.find(name)
-    end
-
-    def self.key(name)
-      "Fragment:#{name}"
-    end
+    attr_reader :name
 
-    def self.tags_for(name)
-      "TagsFor:#{name}"
+    def self.all
+      "AllFragments"
     end
 
-    def initialize(data = nil, tag_names = nil)
-      create(data, tag_names) if data && tag_names
+    def self.find(nice_cache, name)
+      new(nice_cache, name)
     end
 
-    def create(data, tag_names)
-      @name = stringify(tag_names)
-      @data = data
-      attach_tags(tag_names)
-      save_to_redis
-    end
-
-    def find(name)
+    def initialize(nice_cache, name, tag_names = [])
+      @nice_cache = nice_cache
       @name = name
-      @data = data_from_redis
-      self
+      unless tag_names.empty?
+        attach_tags(tag_names)
+        persist
+      end
     end
 
     def tags
-      Tag.find(redis_tag_names)
+      Tag.find(@nice_cache, tags_list)
     end
 
     def attach_with(tag)
-      redis.sadd(attached_tags, tag.name)
+      store.sadd(tags_for_me, tag.name)
     end
 
-    def destroy
+    def delete
       tags.each do |tag|
         tag.remove_from(self)
       end
+      # TODO: Timestamps
 
-      redis.srem(NiceCache.all_fragments_key, @name)
-      redis.del attached_tags
-      redis.del fragment_key
+      destroy
     end
 
     def ==(other)
-      [name, data] == [other.name, other.data]
+      name == other.name
     rescue
       false
     end
 
     private
 
-    def attach_tags(tag_names)
-      Tag.find(tag_names).map{ |tag| tag.attach_on(self) }
-    end
-
-    def stringify(tag_names)
-      tag_names.map{ |tag| tag.to_s.capitalize }.join("-")
+    def self.tags_for(name)
+      "TagsFor:#{name}"
     end
 
-    def attached_tags
+    def tags_for_me
       self.class.tags_for(@name)
     end
 
-    def fragment_key
-      self.class.key(@name)
+    def persist
+      store.sadd(self.class.all, name)
     end
 
-    def redis_tag_names
-      redis.smembers(attached_tags)
+    def attach_tags(tag_names)
+      Tag.find(@nice_cache, tag_names).map{ |tag| tag.attach_on(self) }
     end
 
-    def save_to_redis
-      redis.sadd(NiceCache.all_fragments_key, @name)
-      redis.set(fragment_key, @data)
+    def tags_list
+      store.smembers(tags_for_me)
     end
 
-    def data_from_redis
-      redis.get(fragment_key)
+    def destroy
+      store.srem(self.class.all, name)
+      store.del tags_for_me
+      @nice_cache.destroy(name)
     end
 
-    def redis
-      NiceCache.redis
+    def store
+      @nice_cache.tag_store
     end
+
+    # def add_timestamp
+    #   redis.sadd(NiceCache.all_fragments_key, @name)
+    # end
   end
 end

data/lib/nice_cache/tag.rb

@@ -1,41 +1,32 @@
-require_relative 'fragment'
-
-module NiceCache
+class NiceCache
   class Tag
     attr_reader :name
 
-    def self.find(*tag_names)
-      Array(tag_names).flatten.map{ |tag_symbol| new(tag_symbol) }
-    end
-
-    def self.key(name)
-      "Tag:#{name}"
+    def self.find(nice_cache, *tag_names)
+      tag_names.flatten.map{ |tag_symbol| new(nice_cache, tag_symbol) }
     end
 
-    def initialize(name)
+    def initialize(nice_cache, name)
+      @nice_cache = nice_cache
       @name = name.to_s
     end
 
     def attach_on(fragment)
-      redis.sadd(tag_key, fragment.name)
+      save_fragment(fragment.name)
       fragment.attach_with(self)
       self
     end
 
     def fragments
-      fragment_keys.map{ |fragment_key| Fragment.find(fragment_key) }
-    end
-
-    def tag_key
-      self.class.key(@name)
+      fragments_list.map{ |fragment_name| Fragment.find(@nice_cache, fragment_name) }
     end
 
     def remove_from(fragment)
-      redis.srem(tag_key, fragment.name)
+      store.srem(tag_key, fragment.name)
     end
 
     def sweep
-      fragments.map(&:destroy)
+      fragments.map(&:delete)
       destroy
     end
 
@@ -47,17 +38,28 @@ module NiceCache
 
     private
 
-    def redis
-      NiceCache.redis
+    def store
+      @nice_cache.tag_store
     end
 
-    def destroy
-      redis.del tag_key
+    def self.key(name)
+      "Tag:#{name}"
+    end
+
+    def save_fragment(fragment_name)
+      store.sadd(tag_key, fragment_name)
+    end
+
+    def tag_key
+      self.class.key(@name)
     end
 
-    def fragment_keys
-      redis.smembers(tag_key)
+    def destroy
+      store.del tag_key
     end
 
+    def fragments_list
+      store.smembers(tag_key)
+    end
   end
 end

data/lib/nice_cache/version.rb

@@ -1,3 +1,3 @@
-module NiceCache
-  VERSION = "0.1.0"
+class NiceCache
+  VERSION = "0.2.0"
 end

data/spec/nice_cache/fragment_spec.rb

@@ -3,45 +3,37 @@ require 'mock_redis'
 
 describe NiceCache::Fragment do
 
-  subject(:fragment) { NiceCache::Fragment.new("Some Data", [:Year2014, :Month01, :Date01]) }
+  let(:nice_cache) do
+    NiceCache.new(redis: REDIS) # => from spec/spec_helper.rb
+  end
+  let(:store) { nice_cache.tag_store}
+  
 
   after :all do
     puts "=== Clean up redis ==="
-    puts Benchmark.measure {
-      NiceCache.cleanup
+    puts Benchmark.measure{
+      nice_cache.flush_index!
     }
   end
 
-  before :all do
-    NiceCache.config do |options|
-      options.redis = REDIS # => from spec/spec_helper.rb
-    end
-  end
-
-  describe "#new" do
-    it "has correct name" do
-      expect(fragment.name).to eq "Year2014-Month01-Date01"
-    end
-
-    it "has correct data" do
-      expect(fragment.data).to eq "Some Data"
-    end
-  end
-
-  describe "#find" do
-    let(:fetch_fragment) { NiceCache::Fragment.find("Year2014-Month01-Date01") }
+  subject(:fragment) { NiceCache::Fragment.new(nice_cache, "Foo", [:Year2014, :Month01, :Date01]) }
 
-    it "find correct data with fragment name" do
-      expect(fetch_fragment.data).to eq "Some Data"
-    end
+  it "has correct name" do
+    expect(fragment.name).to eq "Foo"
   end
 
-  it "get correct #tags" do
-    expect(fragment.tags.length).to eq 3
+  it "has correct tags number" do
+    expect(fragment.tags.count).to eq 3
   end
 
   it "can compare with any classes" do
     expect(fragment == []).to be_false
   end
+
+  it "remove fragment after #delete" do
+    expect(store.exists('TagsFor:Foo')).to be_true
+    fragment.delete
+    expect(store.exists('TagsFor:Foo')).to be_false
+  end
 end
 

data/spec/nice_cache/tag_spec.rb

@@ -3,31 +3,51 @@ require 'mock_redis'
 
 describe NiceCache::Tag do
 
-  subject(:tag) { NiceCache::Tag.new(:"Year2014") }
+  let(:nice_cache) do
+    NiceCache.new(redis: REDIS) # => from spec/spec_helper.rb
+  end
+  let(:store) { nice_cache.tag_store }
+  subject(:tag) { NiceCache::Tag.new(nice_cache, :"Year2014") }
 
   after :all do
     puts "=== Clean up redis ==="
-    puts Benchmark.measure {
-      NiceCache.cleanup
+    puts Benchmark.measure{
+      nice_cache.flush_index!
     }
   end
 
-  before :all do
-    NiceCache.config do |options|
-      options.redis = REDIS # => from spec/spec_helper.rb
-    end
-  end
-
   it "have correct name" do
     expect(tag.name).to eq "Year2014"
   end
 
-  describe "#attach_on and #fragments" do
-    it "get correct #fragments after #attach_on" do
-      fragment = NiceCache::Fragment.new("Some Data", [:"Year2014", :"Month01", :"Date01"])
+  it "find tag" do
+    found_tag = NiceCache::Tag.find(nice_cache, :"Year2014")
+    expect(found_tag).to eq [tag]
+  end
+
+  describe "interaction with fragment" do
+
+    let(:fragment) { NiceCache::Fragment.new(nice_cache, "fragment name") }
+
+    before do
       tag.attach_on(fragment)
+    end
+
+    it "get correct #fragments after #attach_on" do
       expect(tag.fragments).to eq [fragment]
     end
+
+    it "clear fragments after #remove_from" do
+      tag.remove_from(fragment)
+      expect(tag.fragments).to eq []
+    end
+
+    it "remove after #sweep" do
+      expect(store.exists("Tag:Year2014")).to be_true
+      tag.sweep
+      expect(store.exists("Tag:Year2014")).to eq false
+    end
+
   end
 
   it "can compare with any classes" do

data/spec/nice_cache_spec.rb

@@ -3,66 +3,86 @@ require 'benchmark'
 
 describe NiceCache do
 
-  it "change redis from #config" do
-    NiceCache.config do |options|
-      options.redis = REDIS # => from spec/spec_helper.rb
-    end
-
-    expect(NiceCache.redis.redis.class).to eq REDIS.class
+  subject(:nice_cache) do
+    NiceCache.new(redis: REDIS) # => from spec/spec_helper.rb
   end
 
   after :all do
     puts "=== Clean up redis ==="
-    puts Benchmark.measure {
-      NiceCache.cleanup
+    puts Benchmark.measure{
+      nice_cache.flush_index!
     }
   end
 
-  before :each do
-    NiceCache.cache("Some Data", tags: [:Year2014, :Month01, :Date01])
-  end
+  it "respond_to all redis public methods" do
+    redis_methods = Redis.instance_methods(false)
 
-  it "cleanup all the fragments and tags" do
-     NiceCache::Fragment.find("Year2014-Month01-Date01")
-     expect(NiceCache.redis.keys("*")).to_not be_empty
-     NiceCache.cleanup
-     expect(NiceCache.redis.keys("*")).to be_empty
+    redis_methods.each do |method|
+      expect(nice_cache.respond_to? method).to be_true
+    end
   end
 
-  let(:found_fragment) { NiceCache::Fragment.find("Year2014-Month01-Date01") }
+  it "pass message to redis by #method_missing" do
+    expect(nice_cache.dbsize.is_a? Fixnum).to be_true
+  end
 
-  it "cache fragment to #fragments" do
-    expect(NiceCache.fragments).to eq [found_fragment]
+  it "not #respond_to wrong methods" do
+    expect(nice_cache.respond_to? :foo).to be_false
   end
 
-  it "remove fragment" do
-    NiceCache.sweep_fragments("Year2014-Month01-Date01")
-    expect(NiceCache.fragments).to eq []
+  context "add a string" do
+
+    before :each do
+      @result = nice_cache.set("foo", "Some Data", tags: [:bar, :baz])
+      @tags =  NiceCache::Tag.find(nice_cache, :bar)
+    end
+
+    it "set a string in redis with tags" do
+      expect(@result).to eq "OK"
+    end
+
+    it "set up the tags" do
+      expect(@tags.first.fragments).to_not be_empty
+    end
+
+    it "delete item in redis" do
+      expect(nice_cache.del "foo").to eq 1
+    end
+
+    it "delete tags and fragment" do
+      expect(nice_cache.tag_store.exists('TagsFor:foo')).to be_true
+      nice_cache.del "foo"
+      expect(nice_cache.tag_store.exists('TagsFor:foo')).to be_false
+    end
   end
 
-  context "multiple fragments" do
+  context "sorted set" do
     before :each do
-      NiceCache.cache("Other Data", tags: [:Year2014, :Month02, :Date01])
+      @result = nice_cache.zadd("TheSortedSet", 1, "one", tags: [:bar, :baz])
     end
 
-    it "get correct #fragments length" do
-      expect(NiceCache.fragments.length).to eq 2
+    it "fetch the correct item with #zrange" do
+      expect(nice_cache.zrange("TheSortedSet", 0, -1)).to eq ["one"]
     end
 
-    it "sweep only one matched fragment" do
-      p Benchmark.measure {
-        NiceCache.sweep_tags(:Month02)
-        expect(NiceCache.fragments.length).to eq 1
-      }
+    it "sweep item with #sweep_tags" do
+      nice_cache.sweep_tags("bar")
+      expect(nice_cache.redis.exists("TheSortedSet")).to be_false
     end
 
-    it "sweep both of matching fragments" do
-      p Benchmark.measure {
-        NiceCache.sweep_tags(:Year2014)
-        expect(NiceCache.fragments.length).to eq 0
-      }
+    it "sweep all item of same tag with #sweep_tags" do
+      nice_cache.set("TheString", "SomeData", tags: [:bar, :foo])
+      expect(nice_cache.redis.exists("TheSortedSet")).to be_true
+      nice_cache.sweep_tags("bar")
+      expect(nice_cache.redis.exists("TheSortedSet")).to be_false
     end
 
+    it "sweep items form #all_fragments" do
+      nice_cache.sadd("TheSet", "SomeData", tags: [:bar, :zoo])
+      expect(nice_cache.all_fragments).to match_array ["TheSortedSet", "TheSet"]
+      nice_cache.sweep_tags("zoo")
+      expect(nice_cache.all_fragments).to eq ["TheSortedSet"]
+    end
   end
 end
 

data/spec/spec_helper.rb

@@ -9,7 +9,8 @@ Dir[File.join(GEM_ROOT, 'spec', 'support', '**/*.rb')].each { |f| require f }
 
 require 'mock_redis'
 require 'redis-namespace'
-REDIS = MockRedis.new
-# REDIS = Redis.new
 
 require 'pry'
+require 'benchmark'
+
+REDIS = Redis::Namespace.new(:Spec, MockRedis.new)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: nice_cache
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Taian Su
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-03-13 00:00:00.000000000 Z
+date: 2014-03-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis