sinarey_cache 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 563d5fbcebdf35c800e8fb4ab1c763e71bbe95ee
+  data.tar.gz: 58be4d2cdac9bbd3cb380111963996dfac9d8ca4
+SHA512:
+  metadata.gz: 0b131394f6b7356ae86224ce6b0d08a1f005861045a176f9f7886ada5e7e313ff438cd96b89b579e05e409efc8f62a9958fa265157e5444fb86afb336f99b97e
+  data.tar.gz: 1ef6d9564726f27767aae31499a2cd95144f1e2529feb3f9bf6f67a91c72f4feb166743f2425978532ff63bd44905af613b0ffeeaa4e282fd16f7c0fae4ecf69

data/lib/sinarey_cache/fifo/cache.rb

@@ -0,0 +1,47 @@
+module Sinarey
+  class FifoCache
+
+    def initialize(max_size)
+      @max_size = max_size
+      @data = {}
+    end
+
+    def max_size=(size)
+      raise ArgumentError.new(:max_size) if @max_size < 1
+      @max_size = size
+    end
+
+    def [](key)
+      @data[key]
+    end
+
+    def fetch(key)
+      @data[key] || yield if block_given?
+    end
+
+    def getset(key)
+      @data[key] ||= yield
+    end
+
+    def []=(key,val)
+      @data[key] = val
+      @data.delete(@data.first[0]) if @data.length > @max_size
+      val
+    end
+
+    alias_method :store,:[]=
+
+    def member?(key)
+      @data.member?(key)
+    end
+
+    def delete(key)
+      @data.delete(key)
+    end
+
+    def clear
+      @data.clear
+    end
+
+  end
+end

data/lib/sinarey_cache/lru_redux/cache.rb

@@ -0,0 +1,91 @@
+module Sinarey
+  class LruCache
+    def initialize(max_size)
+      @max_size = max_size
+      @data = {}
+    end
+
+    def max_size=(size)
+      raise ArgumentError.new(:max_size) if @max_size < 1
+      @max_size = size
+      if @max_size < @data.size
+        @data.keys[0..@max_size-@data.size].each do |k|
+          @data.delete(k)
+        end
+      end
+    end
+
+    def getset(key)
+      found = true
+      value = @data.delete(key){ found = false }
+      if found
+        @data[key] = value
+      else
+        result = @data[key] = yield
+        @data.delete(@data.first[0]) if @data.length > @max_size
+        result
+      end
+    end
+
+    def fetch(key)
+      found = true
+      value = @data.delete(key){ found = false }
+      if found
+        @data[key] = value
+      else
+        yield if block_given?
+      end
+    end
+
+    def [](key)
+      found = true
+      value = @data.delete(key){ found = false }
+      if found
+        @data[key] = value
+      else
+        nil
+      end
+    end
+
+    def []=(key,val)
+      @data.delete(key)
+      @data[key] = val
+      # this may seem odd see: http://bugs.ruby-lang.org/issues/8312
+      @data.delete(@data.first[0]) if @data.length > @max_size
+      val
+    end
+
+    def each
+      array = @data.to_a
+      array.reverse!.each do |pair|
+        yield pair
+      end
+    end
+
+    # used further up the chain, non thread safe each
+    alias_method :each_unsafe, :each
+
+    def to_a
+      array = @data.to_a
+      array.reverse!
+    end
+
+    def delete(k)
+      @data.delete(k)
+    end
+
+    def clear
+      @data.clear
+    end
+
+    def count
+      @data.count
+    end
+
+
+    # for cache validation only, ensures all is sound
+    def valid?
+      true
+    end
+  end
+end

data/lib/sinarey_cache/lru_redux/cache19.rb

@@ -0,0 +1,91 @@
+module Sinarey
+  class LruCache
+    def initialize(max_size)
+      @max_size = max_size
+      @data = {}
+    end
+
+    def max_size=(size)
+      raise ArgumentError.new(:max_size) if @max_size < 1
+      @max_size = size
+      if @max_size < @data.size
+        @data.keys[0..@max_size-@data.size].each do |k|
+          @data.delete(k)
+        end
+      end
+    end
+
+    def getset(key)
+      found = true
+      value = @data.delete(key){ found = false }
+      if found
+        @data[key] = value
+      else
+        result = @data[key] = yield
+        @data.delete(@data.first[0]) if @data.length > @max_size
+        result
+      end
+    end
+
+    def fetch(key)
+      found = true
+      value = @data.delete(key){ found = false }
+      if found
+        @data[key] = value
+      else
+        yield if block_given?
+      end
+    end
+
+    def [](key)
+      found = true
+      value = @data.delete(key){ found = false }
+      if found
+        @data[key] = value
+      else
+        nil
+      end
+    end
+
+    def []=(key,val)
+      @data.delete(key)
+      @data[key] = val
+      # this may seem odd see: http://bugs.ruby-lang.org/issues/8312
+      @data.delete(@data.first[0]) if @data.length > @max_size
+      val
+    end
+
+    def each
+      array = @data.to_a
+      array.reverse!.each do |pair|
+        yield pair
+      end
+    end
+
+    # used further up the chain, non thread safe each
+    alias_method :each_unsafe, :each
+
+    def to_a
+      array = @data.to_a
+      array.reverse!
+    end
+
+    def delete(k)
+      @data.delete(k)
+    end
+
+    def clear
+      @data.clear
+    end
+
+    def count
+      @data.count
+    end
+
+
+    # for cache validation only, ensures all is sound
+    def valid?
+      true
+    end
+  end
+end

data/lib/sinarey_cache/version.rb

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

data/lib/sinarey_cache.rb

@@ -0,0 +1,75 @@
+
+require 'sinarey_cache/fifo/cache'
+
+major,minor = RUBY_VERSION.split(".").map{|a| a.to_i}  
+if major > 1 || (major == 1 && minor > 8)
+  require "sinarey_cache/lru_redux/cache19"
+else
+  require "sinarey_cache/lru_redux/cache"
+end
+
+module Sinarey
+  class SmartCache
+
+    def initialize(data_size,fifo_size)
+      @fifo = Sinarey::FifoCache.new(fifo_size)
+      @data = Sinarey::LruCache.new(data_size)
+    end
+
+    def [](key)
+      @data[key]
+    end
+
+    def fetch(key)
+      if cache = @data[key]
+        return cache
+      else
+        yield if block_given?
+      end
+    end
+
+    def []=(key,val,options={})
+      return @data[key] = val if options[:force]
+      val,version = val,options[:uuid]
+      if @fifo.member?(key)
+        if version.nil?
+          @data[key] = val
+        elsif version!= @fifo[key]
+          @fifo[key] = version
+          @data[key] = val
+        end
+      else
+        @fifo[key] = version
+      end
+      val
+    end
+
+    alias_method :store,:[]=
+
+    def getset(key,options={})
+      if cache = @data[key]
+        return cache
+      else
+        store(key,yield,options) if block_given?
+      end
+    end
+
+    def count
+      @data.count
+    end
+
+    def delete(k)
+      @fifo.delete(k)
+      @data.delete(k)
+    end
+
+    def clear
+      @fifo.clear
+      @data.clear
+    end
+
+  end
+end
+
+
+

data/sinarey_cache.gemspec

@@ -0,0 +1,23 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'sinarey_cache/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "sinarey_cache"
+  spec.version       = SinareyCache::VERSION
+  spec.authors       = ["Jeffrey"]
+  spec.email         = ["jeffrey6052@163.com"]
+  spec.description   = "smart and fast cache"
+  spec.summary       = ""
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = ['lib/sinarey_cache/fifo/cache.rb',
+                        'lib/sinarey_cache/lru_redux/cache.rb',
+                        'lib/sinarey_cache/lru_redux/cache19.rb',
+                        'lib/sinarey_cache/version.rb',
+                        'lib/sinarey_cache.rb',
+                        'test/smart_cache_test.rb',
+                        'sinarey_cache.gemspec']
+end

data/test/smart_cache_test.rb

@@ -0,0 +1,116 @@
+
+$:.unshift File.expand_path("../lib", __dir__)
+
+require 'sinarey_cache'
+require 'minitest/autorun'
+
+ObjectCache = Sinarey::SmartCache.new(100,100)
+
+# MARK 实例方法 []= , store , [], fetch , getset , delete , count , clear
+
+class SmartCacheTest < MiniTest::Unit::TestCase
+
+  def setup
+    @object = {id:1, msg:'this is the object for test', name:'object'}
+    @object1 = {id:2, msg:'I need some more object for test', name:'object1'}
+    @object2 = {id:3, msg:'hahahahaha', name:'object2'}
+  end
+
+  #基本测试 [] , []= , store , fetch, count , delete , clear
+  def test_basic
+
+    obj_id = @object[:id]
+
+    #第一次不会缓存，只在FIFO队列里留下标记
+    ObjectCache[obj_id] = @object
+    assert_equal ObjectCache[obj_id], nil
+    assert_equal ObjectCache.fetch(obj_id), nil
+    assert_equal ObjectCache.count, 0
+
+    #fetch方法，获取不到内容的时候会取后面block返回值
+    #这个方法不会缓存block返回值，另一个getset方法会,并且遵循缓存规则。
+    assert_equal ObjectCache.fetch(obj_id), nil
+    assert_equal ObjectCache.fetch(obj_id){123}, 123
+    assert_equal ObjectCache.count, 0
+
+    #第二次会缓存，因为FIFO队列里已经有标记
+    ObjectCache[obj_id] = @object
+    assert_equal ObjectCache[obj_id], @object
+    assert_equal ObjectCache.fetch(obj_id), @object
+    assert_equal ObjectCache.count, 1
+
+    #fetch方法，有缓存的情况下返回缓存内容
+    assert_equal ObjectCache.fetch(obj_id), @object
+    assert_equal ObjectCache.fetch(obj_id){123}, @object
+    assert_equal ObjectCache.count, 1
+
+    #delete方法 同时清除FIFO队列里的标记
+    ObjectCache.delete(obj_id)
+    assert_equal ObjectCache[obj_id], nil
+    assert_equal ObjectCache.fetch(obj_id), nil
+
+    #按照缓存规则 这一次缓存不会真正建立
+    ObjectCache[obj_id] = @object
+    assert_equal ObjectCache[obj_id], nil
+    assert_equal ObjectCache.fetch(obj_id), nil
+
+    #第二次缓存顺利建立
+    ObjectCache[obj_id] = @object
+    assert_equal ObjectCache[obj_id], @object
+    assert_equal ObjectCache.fetch(obj_id), @object
+
+    #store方法等价于[]=方法
+    ObjectCache.store @object1[:id], @object1
+    #按照规则，需要连写两遍，才能成功缓存
+    ObjectCache.store @object1[:id], @object1
+
+    #调用store方法,可以添加force选项，绕过规则，强制缓存
+    ObjectCache.store @object2[:id], @object2, force:true
+
+    #现在应该有3个缓存
+    assert_equal ObjectCache.count, 3
+
+    #测试clear方法,清空所有缓存和FIFO标记
+    ObjectCache.clear
+    assert_equal ObjectCache.count, 0    
+
+  end
+
+  #测试getset方法 这个方法类似于fetch方法，不同的是，会缓存block的返回值,遵循缓存规则
+  def test_getset_method
+    obj_id = @object[:id]
+
+    assert_equal ObjectCache.count, 0
+
+    ObjectCache.getset(obj_id){ @object }
+    #按照规则这一次缓存也不会建立
+    assert_equal ObjectCache[obj_id], nil
+
+    ObjectCache.getset(obj_id){ @object }
+    #这一次建立成功
+    assert_equal ObjectCache[obj_id], @object
+
+    #同样可以通过force绕过规则强制缓存
+    ObjectCache.getset(@object1[:id],force:true){ @object1 }
+    assert_equal ObjectCache[@object1[:id]], @object1
+
+    ObjectCache.getset(@object2[:id],force:true){ @object2 }
+    assert_equal ObjectCache[@object2[:id]], @object2
+
+
+  end
+
+
+  #同一个用户不可以创建缓存
+  def test_uuid_options
+
+  end
+
+  #可以绕过规则强制建立缓存
+  def test_force_options
+
+  end
+
+end
+
+

metadata

@@ -0,0 +1,51 @@
+--- !ruby/object:Gem::Specification
+name: sinarey_cache
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Jeffrey
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-02-21 00:00:00.000000000 Z
+dependencies: []
+description: smart and fast cache
+email:
+- jeffrey6052@163.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/sinarey_cache/fifo/cache.rb
+- lib/sinarey_cache/lru_redux/cache.rb
+- lib/sinarey_cache/lru_redux/cache19.rb
+- lib/sinarey_cache/version.rb
+- lib/sinarey_cache.rb
+- test/smart_cache_test.rb
+- sinarey_cache.gemspec
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.14
+signing_key: 
+specification_version: 4
+summary: ''
+test_files: []