elephas 0.1.0 → 1.0.0

data/lib/elephas/providers/ruby_on_rails.rb

@@ -21,15 +21,15 @@ module Elephas
       # Writes a value to the cache.
       #
       # @param key [String] The key to associate the value with.
-      # @param value [Object] The value to write. **Setting a value to `nil` doesn't mean *deleting* the value.
-      # @param options [Hash] A list of options for writing. @see Elephas::Cache.write
+      # @param value [Object] The value to write. **Setting a value to `nil` **doesn't** mean *deleting* the value.
+      # @param options [Hash] A list of options for writing.
+      # @see Elephas::Cache.setup_options
       # @return [Object] The value itself.
       def write(key, value, options = {})
-        ttl = [options[:ttl].to_integer, 0].max
         fvalue = ::Elephas::Entry.ensure(value, key, options)
         fvalue.refresh
 
-        Rails.cache.write(key, value, :expires_in => ttl)
+        Rails.cache.write(key, value, :expires_in => fvalue.ttl)
         value
       end
 

data/lib/elephas/version.rb

@@ -11,10 +11,10 @@ module Elephas
   # @see http://semver.org
   module Version
     # The major version.
-    MAJOR = 0
+    MAJOR = 1
 
     # The minor version.
-    MINOR = 1
+    MINOR = 0
 
     # The patch version.
     PATCH = 0

data/spec/elephas/cache_spec.rb

@@ -6,36 +6,103 @@
 
 require "spec_helper"
 
-describe Elephas::Cache do
-  pending ".use" do
+describe ::Elephas::Cache do
+  let(:entry) { ::Elephas::Entry.ensure("VALUE", ::Elephas::Cache.default_prefix + "[KEY]", {:ttl => 3600}) }
 
+  describe ".use" do
+    before(:each) do
+      ::Elephas::Cache.provider = Elephas::Providers::Hash.new
+    end
+
+    it "should use the provider for reading the value" do
+      ::Elephas::Cache.provider.should_receive(:read)
+      ::Elephas::Cache.use("KEY") do "VALUE" end
+    end
+
+    it "should skip the provider if requested to" do
+      ::Elephas::Cache.use("KEY", {:ttl => 0}) do "VALUE" end
+      ::Elephas::Cache.provider.should_not_receive(:read)
+      ::Elephas::Cache.use("KEY", {:force => true}) do "VALUE" end
+      ::Elephas::Cache.provider.should_not_receive(:read)
+    end
+
+    it "should use the block for value computation" do
+      expect{ ::Elephas::Cache.use("KEY") do raise ArgumentError end }.to raise_error(ArgumentError)
+    end
+
+    it "should not use the block if the value is valid" do
+      ::Elephas::Cache.use("KEY") do entry end
+      expect{ ::Elephas::Cache.use("KEY") do raise ArgumentError end }.not_to raise_error(ArgumentError)
+    end
+
+    it "should store the value in the cache" do
+      ::Elephas::Cache.use("KEY") do entry end
+      expect(::Elephas::Cache.provider.read(entry.hash)).to eq(entry)
+    end
+
+    it "should return the entire entry or only the value" do
+      ::Elephas::Cache.use("KEY") do "VALUE" end
+
+      expect(::Elephas::Cache.use("KEY")).to eq("VALUE")
+      value = ::Elephas::Cache.use("KEY", {:as_entry => true})
+      expect(value).to be_a(::Elephas::Entry)
+      expect(value.value).to eq("VALUE")
+    end
   end
 
   describe ".read" do
     it "should be forwarded to the provider" do
-      Elephas::Cache.provider.should_receive(:read)
-      Elephas::Cache.read("KEY")
+      ::Elephas::Cache.provider.should_receive(:read)
+      ::Elephas::Cache.read("KEY")
     end
   end
 
   describe ".write" do
     it "should be forwarded to the provider" do
-      Elephas::Cache.provider.should_receive(:write)
-      Elephas::Cache.write("KEY", "VALUE")
+      ::Elephas::Cache.provider.should_receive(:write)
+      ::Elephas::Cache.write("KEY", "VALUE")
     end
   end
 
   describe ".delete" do
     it "should be forwarded to the provider" do
-      Elephas::Cache.provider.should_receive(:delete)
-      Elephas::Cache.delete("KEY")
+      ::Elephas::Cache.provider.should_receive(:delete)
+      ::Elephas::Cache.delete("KEY")
     end
   end
 
   describe ".exists?" do
     it "should be forwarded to the provider" do
-      Elephas::Cache.provider.should_receive(:exists?)
-      Elephas::Cache.exists?("KEY")
+      ::Elephas::Cache.provider.should_receive(:exists?)
+      ::Elephas::Cache.exists?("KEY")
+    end
+  end
+
+  describe "setup_options" do
+    it "should set good defaults for options" do
+      options_hashes = [
+        nil,
+        "A",
+        {:ttl => 2.hour},
+        {:force => true},
+        {:as_entry => true},
+        {:prefix => "prefix", :hash => "1f3caa3bd0b7ba49dc25f9445abdd4fed6fe65236681b392f0da251673885ea9"},
+        {:hash => "hash"}
+      ]
+
+      reference_hashes = [
+        {:key => "KEY", :ttl => 1.hour * 1000, :force => false, :as_entry => false, :prefix => ::Elephas::Cache.default_prefix, :complete_key => "#{::Elephas::Cache.default_prefix}[KEY]", :hash => "8a7675d5f1d9b163bb7bb4329c1a59ff18870fad4ed35a3a2e8d195a6f3c0332"},
+        {:key => "KEY", :ttl => 1.hour * 1000, :force => false, :as_entry => false, :prefix => ::Elephas::Cache.default_prefix, :complete_key => "#{::Elephas::Cache.default_prefix}[KEY]", :hash => "8a7675d5f1d9b163bb7bb4329c1a59ff18870fad4ed35a3a2e8d195a6f3c0332"},
+        {:key => "KEY", :ttl => 2.hour, :force => false, :as_entry => false, :prefix => ::Elephas::Cache.default_prefix, :complete_key => "#{::Elephas::Cache.default_prefix}[KEY]", :hash => "8a7675d5f1d9b163bb7bb4329c1a59ff18870fad4ed35a3a2e8d195a6f3c0332"},
+        {:key => "KEY", :ttl => 1.hour * 1000, :force => true, :as_entry => false, :prefix => ::Elephas::Cache.default_prefix, :complete_key => "#{::Elephas::Cache.default_prefix}[KEY]", :hash => "8a7675d5f1d9b163bb7bb4329c1a59ff18870fad4ed35a3a2e8d195a6f3c0332"},
+        {:key => "KEY", :ttl => 1.hour * 1000, :force => false, :as_entry => true, :prefix => ::Elephas::Cache.default_prefix, :complete_key => "#{::Elephas::Cache.default_prefix}[KEY]", :hash => "8a7675d5f1d9b163bb7bb4329c1a59ff18870fad4ed35a3a2e8d195a6f3c0332"},
+        {:key => "KEY", :ttl => 1.hour * 1000, :force => false, :as_entry => false, :prefix => "prefix", :complete_key => "prefix[KEY]", :hash => "1f3caa3bd0b7ba49dc25f9445abdd4fed6fe65236681b392f0da251673885ea9"},
+        {:key => "KEY", :ttl => 1.hour * 1000, :force => false, :as_entry => false, :prefix => ::Elephas::Cache.default_prefix, :complete_key => "#{::Elephas::Cache.default_prefix}[KEY]", :hash => "hash"}
+      ]
+
+      options_hashes.each_with_index do |options, i|
+        expect(::Elephas::Cache.setup_options(options, "KEY")).to eq(reference_hashes[i])
+      end
     end
   end
 end

data/spec/elephas/entry_spec.rb

@@ -7,5 +7,95 @@
 require "spec_helper"
 
 describe Elephas::Entry do
+  subject { ::Elephas::Entry.new("KEY", "VALUE") }
 
+  describe "#initialize" do
+    it "should initialize with good defaults" do
+      ::Time.stub(:now).and_return(123.456)
+      expect(subject.key).to eq("KEY")
+      expect(subject.value).to eq("VALUE")
+      expect(subject.hash).to eq("5ca24005b740717ba4f3f6bc48a230700e68c2a4b11ecedb96f169f4efaf1f21")
+      expect(subject.ttl).to eq(360000)
+      expect(subject.updated_at).to eq(123.456)
+
+      ::Time.stub(:now).and_return(123.789)
+      other = ::Elephas::Entry.new("KEY 1", "VALUE 1", "HASH", 7200)
+      expect(other.key).to eq("KEY 1")
+      expect(other.value).to eq("VALUE 1")
+      expect(other.hash).to eq("HASH")
+      expect(other.ttl).to eq(7200)
+      expect(other.updated_at).to eq(123.789)
+    end
+  end
+
+  describe "#refresh" do
+    before(:each) do
+      ::Time.stub(:now).and_return(123.123)
+    end
+
+    it "should update the updated_at field" do
+      expect(subject.updated_at).to eq(123.123)
+      ::Time.stub(:now).and_return(456.456)
+      subject.refresh
+      expect(subject.updated_at).to eq(456.456)
+    end
+
+    it "should save to the cache" do
+      expect(::Elephas::Cache.provider.read(subject.hash)).not_to eq(subject)
+      subject.refresh(true)
+      expect(::Elephas::Cache.provider.read(subject.hash)).to eq(subject)
+    end
+  end
+
+  describe "#valid?" do
+    before(:each) do
+      ::Time.stub(:now).and_return(100)
+    end
+
+    it "should return true if the ttl is still valid" do
+      ::Time.stub(:now).and_return(1000)
+      expect(subject.valid?).to be_true
+    end
+
+    it "should return true if the ttl has expired" do
+      ::Time.stub(:now).and_return(10000)
+      subject.updated_at = 1000
+      expect(subject.valid?).to be_false
+    end
+  end
+
+  describe "==" do
+    it "should correctly compare with other entries" do
+      expect(subject == subject).to be_true
+      expect(subject == ::Elephas::Entry.new("KEY", "VALUE")).to be_true
+      expect(subject == ::Elephas::Entry.new("KEY", "VALUE 1")).to be_false
+      expect(subject == ::Elephas::Entry.new("KEY 1", "VALUE")).to be_false
+      expect(subject == ::Elephas::Entry.new("KEY", "VALUE", "HASH")).to be_false
+    end
+
+    it "should return false for other type" do
+      expect(subject == nil).to be_false
+      expect(subject == "A").to be_false
+    end
+  end
+
+  describe ".hashify_key" do
+    it "should compute a good hash" do
+      expect(::Elephas::Entry.hashify_key("HASH 1")).to eq("88e1f3572122e2605c1fab09efa8d4e99f5a064ae0230ca0aeced839796aba35")
+      expect(::Elephas::Entry.hashify_key("HASH 2")).to eq("38589cee32e00f700cf958dfe98f17d6da231700c41586e3c32b00314bb3cb58")
+      expect(::Elephas::Entry.hashify_key(nil)).to eq("e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855")
+    end
+  end
+
+  describe ".ensure" do
+    it "should wrap the value" do
+      expect(::Elephas::Entry.ensure(nil, "KEY 1")).to eq(::Elephas::Entry.new("KEY 1", nil))
+      expect(::Elephas::Entry.ensure("A", "KEY 2")).to eq(::Elephas::Entry.new("KEY 2", "A"))
+      expect(::Elephas::Entry.ensure([], "KEY 3")).to eq(::Elephas::Entry.new("KEY 3", []))
+    end
+
+    it "should not alter Entry objects" do
+      expect(::Elephas::Entry.ensure(subject, "ANOTHER KEY")).to eq(subject)
+    end
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: elephas
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 1.0.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-07-28 00:00:00.000000000 Z
+date: 2012-07-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: cowtech-extensions
@@ -204,7 +204,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 2608788952293416880
+      hash: 3704477900054561540
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -213,7 +213,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 2608788952293416880
+      hash: 3704477900054561540
 requirements: []
 rubyforge_project: elephas
 rubygems_version: 1.8.24