norton 0.0.26 → 0.0.28

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: dcc25c436cc01399c68e17739b2181d7298e5a05
-  data.tar.gz: 9add33b7a73eb52e1cceaceecee1728db377ae15
+  metadata.gz: 6b7c3999eddbe0fe7c432929c4a64337f7d13582
+  data.tar.gz: ff3c8b2858a68fb58992cf20007c9240fd0669a6
 SHA512:
-  metadata.gz: e8dd9328148d9ec90be45726443cdadabbf99de363c11a9680897f53886f6cf5aabe8b6de429c9c92e28986b8ee4d03f95c1a63e0543116f3c7146e3725ac8ee
-  data.tar.gz: 3e7b992f5406d3c3876f1e065f108a5d3c0bc690bb90429d85f6709980c9d14a02abd1f88252cce62ab9d39f01ef482b94a950a8dc01fb2d8513ddbfb9df9c05
+  metadata.gz: dab5a67c19f6ed9c13b7c10e52399fb3b5e230333deee5ccf74ee50b030e8534edcfa143038723bef88db5ae2fa583221c48b5dea9f9a32e97e951bae183859c
+  data.tar.gz: 1404ed9e20b18ab3f66c49cf648fb17bd91dece915fc572b3b652a554db27c94aed79809f1f9446836d614b25fafc9fcf47eb54841d14db45af7e64aea598210

data/.travis.yml

@@ -4,7 +4,7 @@ services:
   - redis-server
 
 rvm:
-  - 2.3.0
+  - 2.3.4
 
 script:
   - bundle exec rake

data/CHANGLOG.md

@@ -0,0 +1,7 @@
+### 0.0.28
+
+- Fix `remove_#{norton_attribute}`
+
+### 0.0.27
+
+- Save loaded values in instance variable, now calling get method will not contact redis if already loaded.

data/lib/norton/counter.rb

@@ -15,75 +15,91 @@ module Norton
       #
       # @return [type] [description]
       def counter(name, options={}, &blk)
-        self.register_norton_value(name, :counter)
+        register_norton_value(name, :counter)
 
+        # Redis: GET
         define_method(name) do
-          Norton.redis.with do |conn|
-            conn.get(self.norton_value_key(name)).try(:to_i) || send("#{name}_default_value".to_sym)
+          instance_variable_get("@#{name}") || begin
+            value = Norton.redis.with do |conn|
+              conn.get(norton_value_key(name))
+            end || send("#{name}_default_value")
+            instance_variable_set("@#{name}", value.to_i)
+          end
+        end
+
+        # Redis: SET
+        define_method("#{name}=") do |value|
+          if Norton.redis.with { |conn| conn.set(norton_value_key(name), value) }
+            instance_variable_set("@#{name}", value.to_i)
           end
         end
 
         define_method("#{name}_default_value") do
           0
         end
-        send(:private, "#{name}_default_value".to_sym)
 
+        # Redis: INCR
         define_method("incr_#{name}") do
-          Norton.redis.with do |conn|
-            conn.incr(self.norton_value_key(name))
+          value = Norton.redis.with do |conn|
+            conn.incr(norton_value_key(name))
           end
+          instance_variable_set("@#{name}", value.to_i)
         end
 
+        # Redis: DECR
         define_method("decr_#{name}") do
-          Norton.redis.with do |conn|
-            conn.decr(self.norton_value_key(name))
+          value = Norton.redis.with do |conn|
+            conn.decr(norton_value_key(name))
           end
+          instance_variable_set("@#{name}", value.to_i)
         end
 
+        # Redis: INCRBY
         define_method("incr_#{name}_by") do |increment|
-          Norton.redis.with do |conn|
-            conn.incrby(self.norton_value_key(name), increment)
+          value = Norton.redis.with do |conn|
+            conn.incrby(norton_value_key(name), increment)
           end
+          instance_variable_set("@#{name}", value.to_i)
         end
 
+        # Redis: DECRBY
         define_method("decr_#{name}_by") do |decrement|
-          Norton.redis.with do |conn|
-            conn.decrby(self.norton_value_key(name), decrement)
-          end
-        end
-
-        define_method("#{name}=") do |v|
-          Norton.redis.with do |conn|
-            conn.set(self.norton_value_key(name), v)
+          value = Norton.redis.with do |conn|
+            conn.decrby(norton_value_key(name), decrement)
           end
+          instance_variable_set("@#{name}", value.to_i)
         end
 
+        # Redis: SET
         define_method("reset_#{name}") do
-          count = instance_eval(&blk)
+          value = instance_eval(&blk)
 
           Norton.redis.with do |conn|
-            conn.set(self.norton_value_key(name), count)
+            conn.set(norton_value_key(name), value)
           end
+          instance_variable_set("@#{name}", value)
         end
 
+        # Redis: DEL
         define_method("remove_#{name}") do
           Norton.redis.with do |conn|
-            conn.del(self.norton_value_key(name))
+            conn.del(norton_value_key(name))
           end
+          remove_instance_variable("@#{name}") if instance_variable_defined?("@#{name}")
         end
         send(:after_destroy, "remove_#{name}".to_sym) if respond_to? :after_destroy
 
         # Add Increment callback
         unless options[:incr].nil?
           options[:incr].each do |callback|
-            self.send callback, proc{ instance_eval("incr_#{name}") }
+            send callback, proc{ instance_eval("incr_#{name}") }
           end
         end
 
         # Add Decrement callback
         unless options[:decr].nil?
           options[:decr].each do |callback|
-            self.send callback, proc{ instance_eval("decr_#{name}") }
+            send callback, proc{ instance_eval("decr_#{name}") }
           end
         end
       end

data/lib/norton/helper.rb

@@ -9,6 +9,19 @@ module Norton
     module ClassMethods
       attr_reader :norton_values
 
+      #
+      # 当定义一个 Norton Value 的时候，将这个 Norton Value 记录在 Class Variable `@norton_values` 中
+      #
+      #
+      # @return [void]
+      #
+      def register_norton_value(name, norton_type)
+        if !Norton::SUPPORTED_TYPES.include?(norton_type.to_sym)
+          raise Norton::InvalidType.new("Norton Type: #{norton_type} invalid!")
+        end
+
+        @norton_values[name.to_sym] = norton_type.to_sym
+      end
 
       #
       # 当前类是否定义了某个 Norton Value
@@ -18,7 +31,7 @@ module Norton
       # @return [Boolean]
       #
       def norton_value_defined?(name)
-        self.norton_values.has_key?(name.to_sym)
+        norton_values.has_key?(name.to_sym)
       end
 
       #
@@ -29,21 +42,7 @@ module Norton
       # @return [Symbol]
       #
       def norton_value_type(name)
-        self.norton_values[name.to_sym].try(:to_sym)
-      end
-
-      #
-      # 当定义一个 Norton Value 的时候，将这个 Norton Value 记录在 Class Variable `@norton_values` 中
-      #
-      #
-      # @return [void]
-      #
-      def register_norton_value(name, norton_type)
-        if !Norton::SUPPORTED_TYPES.include?(norton_type.to_sym)
-          raise Norton::InvalidType.new("Norton Type: #{norton_type} invalid!")
-        end
-
-        @norton_values[name.to_sym] = norton_type.to_sym
+        norton_values[name.to_sym]
       end
     end
 
@@ -63,7 +62,7 @@ module Norton
       id = self.id
       raise Norton::NilObjectId if id.nil?
       klass = self.class.to_s.pluralize.underscore
-      "#{klass}:#{self.id}"
+      "#{klass}:#{id}"
     end
 
     #
@@ -80,46 +79,48 @@ module Norton
     # @return [String]
     #
     def norton_value_key(name)
-      "#{self.norton_prefix}:#{name}"
+      "#{norton_prefix}:#{name}"
     end
 
+    def cast_value(type, value)
+      case type.to_sym
+      when :counter then value.to_i
+      when :timestamp then value.to_i
+      end
+    end
+
+    # 批量取出当前对象的多个 Norton 字段, 仅仅支持 counter / timestamp
     #
-    # 批量取出当前对象的多个 Norton value, 仅仅支持 counter / timestamp
-    #
-    # @param [Array] *value_keys 直接传入需要的值的 key，例如: :key1, :key2, :key3
+    # @param [Array] names 需要检索的字段, 例如: :field1, :field2
     #
-    # @return [Hash]
+    # @return [Model] 当前对象
     #
     def norton_mget(*names)
-      ret = {}
+      values = Norton.redis.with do |conn|
+        conn.mget(names.map { |name| norton_value_key(name) })
+      end
 
-      redis_keys = names.map { |n| self.norton_value_key(n) }
+      assign_values(names.zip(values).to_h)
 
-      Norton.redis.with do |conn|
-        # mget 一次取出所有的值
-        redis_values = conn.mget(redis_keys)
+      self
+    end
 
-        # 组装结果 Hash
-        names.each_with_index do |n, index|
-          val = redis_values[index].try(:to_i)
+    # :nodoc
+    def assign_values(new_values)
+      new_values.each do |field, val|
+        type = self.class.norton_value_type(field)
+        next unless %i[counter timestamp].include?(type)
 
-          # 如果返回值为 nil 并且定义了这个 norton value
-          # 那么获取返回值
-          if val.nil? && self.class.norton_value_defined?(n)
-            val = send("#{n}_default_value".to_sym)
+        value = cast_value(type, val || try("#{field}_default_value"))
+        instance_variable_set("@#{field}", value)
 
-            # 如果返回值不为空，将默认值存入 SSDB
-            # 并且当前 Value 是 `:timestamp`
-            if !val.nil? && self.class.norton_value_type(n) == :timestamp
-              conn.set(self.norton_value_key(n), val)
-            end
+        if type == :timestamp && val.nil? && !try("#{field}_default_value").nil?
+          Norton.redis.with do |conn|
+            conn.set(norton_value_key(field), value)
           end
-
-          ret[n] = val
         end
       end
-
-      ret
     end
+    send(:private, :assign_values)
   end
 end

data/lib/norton/timestamp.rb

@@ -14,52 +14,44 @@ module Norton
       #
       # @return [type] [description]
       def timestamp(name, options={})
-        self.register_norton_value(name, :timestamp)
+        register_norton_value(name, :timestamp)
 
+        # Redis: GET
         define_method(name) do
-          ts = nil
+          value = Norton.redis.with do |conn|
+            raw_value = conn.get(norton_value_key(name))
+            break raw_value if raw_value.present?
 
-          Norton.redis.with do |conn|
-            ts = conn.get(self.norton_value_key(name)).try(:to_i)
-
-            if ts.nil?
-              ts = send("#{name}_default_value".to_sym)
-              conn.set(self.norton_value_key(name), ts) if !ts.nil?
+            send("#{name}_default_value").tap do |default_value|
+              conn.set(norton_value_key(name), default_value)
             end
-
-            ts
           end
+          instance_variable_set("@#{name}", value.to_i)
         end
 
         define_method("#{name}_default_value") do
-          if !options[:allow_nil]
-            if options[:digits].present? && options[:digits] == 13
-              ts = (Time.now.to_f * 1000).to_i
-            else
-              ts = Time.now.to_i
-            end
+          return nil if options[:allow_nil]
+          return (Time.current.to_f * 1000).to_i if options[:digits] == 13
 
-            ts
-          else
-            nil
-          end
+          Time.current.to_i
         end
-        send(:private, "#{name}_default_value".to_sym)
 
+        # Redis: SET
         define_method("touch_#{name}") do
+          value = options[:digits] == 13 ? (Time.current.to_f * 1000).to_i : Time.current.to_i
+
           Norton.redis.with do |conn|
-            if options[:digits].present? && options[:digits] == 13
-              conn.set(self.norton_value_key(name), (Time.now.to_f * 1000).to_i)
-            else
-              conn.set(self.norton_value_key(name), Time.now.to_i)
-            end
+            conn.set(norton_value_key(name), value)
           end
+          instance_variable_set("@#{name}", value)
         end
 
+        # Redis: DEL
         define_method("remove_#{name}") do
           Norton.redis.with do |conn|
-            conn.del("#{self.class.to_s.pluralize.underscore}:#{self.id}:#{name}")
+            conn.del(norton_value_key(name))
           end
+          remove_instance_variable("@#{name}") if instance_variable_defined?("@#{name}")
         end
         send(:after_destroy, "remove_#{name}".to_sym) if respond_to? :after_destroy
 

data/lib/norton/version.rb

@@ -1,3 +1,3 @@
 module Norton
-  VERSION = "0.0.26"
+  VERSION = "0.0.28"
 end

data/lib/norton.rb

@@ -37,82 +37,28 @@ module Norton
       end
     end
 
+    # 批量获取多个对象的多个 Norton 字段, 仅仅支持 counter / timestamp
     #
-    # 为多个 Norton 对象一次性取出多个值
+    # @example
+    #   Norton.mget([a_user, another_user], [:followers_count, :profile_updated_at])
     #
-    # 从一组相同的对象中，一次性取出多个 Norton 值。
+    # @param [Array] names 需要检索的字段
     #
-    # 例如:
+    # @return [Array] 一组对象
     #
-    # vals = Norton.mget([user1, user2, user3], [followers_count, profile_updated_at])
-    #
-    # 将会返回:
-    #
-    # ```
-    # {
-    #   "users:1:followers_count": 2,
-    #   "users:2:followers_count": 3,
-    #   "users:3:followers_count": 4,
-    #   "users:1:profile_updated_at": 1498315792,
-    #   "users:2:profile_updated_at": 1499315792,
-    #   "users:3:profile_updated_at": 1409315792,
-    # }
-    # ```
-    #
-    # * 返回的 Field 之间的顺序无法保证
-    #
-    # @param [Array] objects
-    # @param [Array] names
-    #
-    # @return [Hash]
-    #
-    def mget(objects, names)
-      ret = {}
-
-      mapping = {}
-      redis_keys = []
-
-      objects.each_with_index do |obj, index|
-        next if obj.nil?
-
-        names.each do |n|
-          redis_key = obj.norton_value_key(n)
-
-          redis_keys << redis_key
-          mapping[redis_key] = [n, index]
-        end
+    def mget(objects, fields)
+      keys = objects.flat_map do |object|
+        fields.map { |f| object.norton_value_key(f) }
       end
+      nested_values = Norton.redis.with do |conn|
+        conn.mget(keys)
+      end.each_slice(fields.size)
 
-      Norton.redis.with do |conn|
-        values = conn.mget(redis_keys)
-
-        redis_keys.each_with_index do |k, i|
-          val = values[i].try(:to_i)
-
-          # 如果返回值为 nil 并且定义了这个 norton value
-          # 那么获取返回值
-          if val.nil?
-            # 从 mapping 中取出 value name 和对应的 object
-            value_name, obj_index = mapping[k]
-            obj = objects[obj_index]
-
-            # 如果 object 定义了这个 value
-            if obj.class.norton_value_defined?(value_name)
-              # 获取默认值
-              val = obj.send("#{value_name}_default_value".to_sym)
-
-              # 如果返回值不为空，并且当前 value 的类型是 `timestamp` 将默认值存入 Redis
-              if !val.nil? && obj.class.norton_value_type(value_name) == :timestamp
-                conn.set(k, val)
-              end
-            end
-          end
-
-          ret[k] = val
-        end
+      objects.zip(nested_values).each do |object, values|
+        object.send(:assign_values, fields.zip(values).to_h)
       end
 
-      ret
+      objects
     end
   end
 end

data/spec/norton/counter_spec.rb

@@ -1,10 +1,9 @@
-require 'spec_helper'
+require "spec_helper"
 
 class Dummy
   include Norton::Counter
 
   counter :candies_count, {} do
-    # puts 'hahaha'
     candies
   end
 
@@ -18,40 +17,127 @@ class Dummy
 end
 
 describe Norton::Counter do
-  describe "reset counter" do
-    it 'should set candies_count' do
-      dummy = Dummy.new
-      dummy.reset_candies_count
+  let(:dummy) { Dummy.new }
+
+  it "responds to methods" do
+    expect(dummy.respond_to?(:candies_count)).to be(true)
+    expect(dummy.respond_to?(:candies_count=)).to be(true)
+    expect(dummy.respond_to?(:candies_count_default_value)).to be(true)
+    expect(dummy.respond_to?(:incr_candies_count)).to be(true)
+    expect(dummy.respond_to?(:decr_candies_count)).to be(true)
+    expect(dummy.respond_to?(:incr_candies_count_by)).to be(true)
+    expect(dummy.respond_to?(:decr_candies_count_by)).to be(true)
+    expect(dummy.respond_to?(:reset_candies_count)).to be(true)
+  end
+
+  describe "#candies_count" do
+    it "returns the value correctly" do
+      allow(dummy).to receive(:candies_count_default_value) { 123 }
+
+      expect(dummy.candies_count).to eq(123)
+      expect(dummy.instance_variable_get(:@candies_count)).to eq(123)
+    end
+  end
+
+  describe "#candies_count=" do
+    it "assigns a value to the counter" do
+      dummy.candies_count = "200"
+
+      value_in_redis = Norton.redis.with do |conn|
+        conn.get(dummy.norton_value_key(:candies_count))
+      end
+      expect(value_in_redis.to_i).to eq(200)
+      expect(dummy.instance_variable_get(:@candies_count)).to eq(200)
+    end
+  end
+
+  describe "#candies_count_default_value" do
+    it "returns correct default value" do
+      expect(dummy.candies_count_default_value).to eq(0)
+    end
+  end
 
-      expect(dummy.candies_count).to eq(15)
+  describe "#incr_candies_count" do
+    it "increases the value by one" do
+      dummy.incr_candies_count
+
+      value_in_redis = Norton.redis.with do |conn|
+        conn.get(dummy.norton_value_key(:candies_count))
+      end
+      expect(value_in_redis.to_i).to eq(1)
+      expect(dummy.instance_variable_get(:@candies_count)).to eq(1)
     end
   end
 
-  describe "assign value to counter" do
-    it 'should be able to assign a value to the counter' do
-      dummy = Dummy.new
-      dummy.candies_count = 200
+  describe "#decr_candies_count" do
+    it "decreases the value by one" do
+      dummy.candies_count = 15
+      dummy.decr_candies_count
 
-      expect(dummy.candies_count).to eq(200)
+      value_in_redis = Norton.redis.with do |conn|
+        conn.get(dummy.norton_value_key(:candies_count))
+      end
+      expect(value_in_redis.to_i).to eq(14)
+      expect(dummy.instance_variable_get(:@candies_count)).to eq(14)
     end
   end
 
-  describe ".incr_value_by" do
-    it "should increase the value of the given amount" do
-      dummy = Dummy.new
+  describe "#incr_candies_count_by" do
+    it "increases the value of the given amount" do
       dummy.incr_candies_count_by(3)
 
-      expect(dummy.candies_count).to eq(3)
+      value_in_redis = Norton.redis.with do |conn|
+        conn.get(dummy.norton_value_key(:candies_count))
+      end
+      expect(value_in_redis.to_i).to eq(3)
+      expect(dummy.instance_variable_get(:@candies_count)).to eq(3)
     end
   end
 
-  describe ".decr_value_by" do
-    it "should decrease the value of the given amount" do
-      dummy = Dummy.new
+  describe "#decr_candies_count_by" do
+    it "decreases the value of the given amount" do
       dummy.candies_count = 15
       dummy.decr_candies_count_by(5)
 
-      expect(dummy.candies_count).to eq(10)
+      value_in_redis = Norton.redis.with do |conn|
+        conn.get(dummy.norton_value_key(:candies_count))
+      end
+      expect(value_in_redis.to_i).to eq(10)
+      expect(dummy.instance_variable_get(:@candies_count)).to eq(10)
+    end
+  end
+
+  describe "#reset_candies_count" do
+    it "resets candies_count" do
+      dummy.reset_candies_count
+
+      value_in_redis = Norton.redis.with do |conn|
+        conn.get(dummy.norton_value_key(:candies_count))
+      end
+      expect(value_in_redis.to_i).to eq(15)
+      expect(dummy.instance_variable_get(:@candies_count)).to eq(15)
+    end
+  end
+
+  describe "#remove_candies_count" do
+    it "deletes candies_count in redis" do
+      dummy.incr_candies_count_by(5)
+      expect(
+        Norton.redis.with { |conn| conn.exists(dummy.norton_value_key(:candies_count)) }
+      ).to be(true)
+
+      dummy.remove_candies_count
+      expect(
+        Norton.redis.with { |conn| conn.exists(dummy.norton_value_key(:candies_count)) }
+      ).to be(false)
+    end
+
+    it "removes the instance variable named by counter" do
+      dummy.incr_candies_count_by(5)
+      expect(dummy.instance_variable_defined?(:@candies_count)).to be(true)
+
+      dummy.remove_candies_count
+      expect(dummy.instance_variable_defined?(:@candies_count)).to be(false)
     end
   end
 end

data/spec/norton/helper_spec.rb

@@ -5,14 +5,10 @@ class Dummy
   include Norton::Timestamp
   include Norton::HashMap
 
-  counter :counter1
-  counter :counter2
-  counter :counter3
-
+  counter   :counter1
   timestamp :time1
-  timestamp :time2
-
-  hash_map :map1
+  timestamp :time2, :allow_nil => true
+  hash_map  :map1
 
   def id
     @id ||= Random.rand(10000)
@@ -30,29 +26,17 @@ module HolyLight
 end
 
 describe Norton::Helper do
-  describe "@norton_values" do
-    it "should contain defined values and type" do
-      expect(Dummy.norton_values[:counter1]).to eq(:counter)
-      expect(Dummy.norton_values[:counter2]).to eq(:counter)
-      expect(Dummy.norton_values[:counter3]).to eq(:counter)
-
-      expect(Dummy.norton_values[:time1]).to eq(:timestamp)
-      expect(Dummy.norton_values[:time2]).to eq(:timestamp)
-
-      expect(Dummy.norton_values[:map1]).to eq(:hash_map)
-    end
-
-    it "should not contain undefined values" do
-      expect(Dummy.norton_values[:foobar]).to be_nil
-    end
-  end
-
   describe ".register_norton_value" do
     it "should raise error if type is not supported" do
       expect {
         Dummy.register_norton_value("foo", "bar")
       }.to raise_error(Norton::InvalidType)
     end
+
+    it "adds the fields with valid type to `@norton_values`" do
+      Dummy.register_norton_value("foo", "counter")
+      expect(Dummy.norton_values[:foo]).to eq(:counter)
+    end
   end
 
   describe ".norton_value_defined?" do
@@ -60,31 +44,30 @@ describe Norton::Helper do
       expect(Dummy.norton_value_defined?(:counter1)).to eq(true)
     end
 
-    it "should return false for a defined value" do
+    it "should return false for a undefined value" do
       expect(Dummy.norton_value_defined?(:time3)).to eq(false)
     end
   end
 
-  describe "#norton_value_key" do
-    it do
-      n = SecureRandom.hex(3)
-
-      dummy = Dummy.new
-      expect(dummy.norton_value_key(n)).to eq("dummies:#{dummy.id}:#{n}")
+  describe ".norton_value_type" do
+    it "returns the type for a defined value" do
+      Dummy.register_norton_value("foo", "counter")
+      expect(Dummy.norton_value_type("foo")).to eq(:counter)
     end
+  end
 
-    it "should raise `Norton::NilObjectId` if id returns nil" do
-      dummy = Dummy.new
-      allow(dummy).to receive(:id) { nil }
+  describe "#norton_prefix" do
+    let(:dummy) { Dummy.new }
+    let(:spammer) { HolyLight::Spammer.new }
 
+    it "raises error if the object's id is nil" do
+      allow(dummy).to receive(:id) { nil }
       expect { dummy.norton_prefix }.to raise_error(Norton::NilObjectId)
     end
-  end
 
-  describe "#norton_prefix" do
-    it "should return correctly for `Dummy`" do
-      dummy = Dummy.new
+    it "returns correctly for valid objects" do
       expect(dummy.norton_prefix).to eq("dummies:#{dummy.id}")
+      expect(spammer.norton_prefix).to eq("holy_light/spammers:#{spammer.id}")
     end
 
     it "should return correctly for `HolyLight::Spammer`" do
@@ -93,87 +76,93 @@ describe Norton::Helper do
     end
   end
 
-  describe "#norton_mget" do
-    it "should respond to `:norton_mget`" do
-      dummy = Dummy.new
-
-      expect(dummy).to respond_to(:norton_mget)
-    end
-
-    it "should return the specific values" do
-      dummy = Dummy.new
+  describe "#norton_value_key" do
+    let(:dummy) { Dummy.new }
 
-      dummy.counter1 = 10
-      dummy.counter2 = 15
-      dummy.counter3 = 100
+    it "returns the redis key correctly" do
+      allow(dummy).to receive(:norton_prefix) { "foobar" }
 
-      dummy.touch_time1
+      expect(dummy.norton_value_key("lol")).to eq("foobar:lol")
+    end
+  end
 
-      values = dummy.norton_mget(:counter1, :time1)
+  describe "#norton_mget" do
+    let(:dummy) { Dummy.new }
 
-      expect(values).to include(:counter1, :time1)
-      expect(values.size).to eq(2)
-      expect(values[:counter1]).to eq(dummy.counter1)
-      expect(values[:time1]).to eq(dummy.time1)
+    context "when the field isn't defined" do
+      it "doesn't set the instance variable" do
+        dummy.norton_mget(:undefined_field)
+        expect(dummy.instance_variable_defined?(:@undefined_field)).to be(false)
+      end
     end
 
-    it "should default value if the value of does not exist" do
-      dummy = Dummy.new
-
-      dummy.counter1 = 10
-      dummy.counter2 = 15
+    context "when the type isn't in the [:counter, :timestamp]" do
+      it "doesn't set the instance variable" do
+        dummy.norton_mget(:map1)
+        expect(dummy.instance_variable_defined?(:@map1)).to be(false)
+      end
+    end
 
-      dummy.touch_time1
+    context "when the type is in the [:counter, :timestamp]" do
+      it "returns norton values correctly from redis" do
+        Norton.redis.with do |conn|
+          conn.set(dummy.norton_value_key(:counter1), 2)
+          conn.set(dummy.norton_value_key(:time1), 1234)
+        end
 
-      t = Time.now
+        dummy.norton_mget(:counter1, :time1)
+        expect(dummy.instance_variable_get(:@counter1)).to eq(2)
+        expect(dummy.instance_variable_get(:@time1)).to eq(1234)
+      end
 
-      Timecop.freeze(t) do
-        values = dummy.norton_mget(:counter1, :counter2, :time2)
+      it "returns the default value if no value in redis" do
+        allow(dummy).to receive(:counter1_default_value) { 99 }
+        allow(dummy).to receive(:time1_default_value) { 1234 }
 
-        expect(values).to include(:counter1, :counter2, :time2)
-        expect(values.size).to eq(3)
-        expect(values[:counter1]).to eq(dummy.counter1)
-        expect(values[:counter2]).to eq(dummy.counter2)
-        expect(values[:time2]).to eq(t.to_i)
+        dummy.norton_mget(:counter1, :time1)
+        expect(dummy.instance_variable_get(:@counter1)).to eq(99)
+        expect(dummy.instance_variable_get(:@time1)).to eq(1234)
       end
     end
 
-    it "should save the default value for timestamp" do
-      dummy = Dummy.new
+    context "when the type is :counter" do
+      it "doesn't save the default value in redis if no value in redis" do
+        allow(dummy).to receive(:counter1_default_value) { 99 }
 
-      t = Time.now
+        dummy.norton_mget(:counter1)
 
-      Timecop.freeze(t) do
-        values = dummy.norton_mget(:time2)
-        expect(values[:time2]).to eq(t.to_i)
-
-        # Test value directly from Redis
-        val = Norton.redis.with { |conn| conn.get(dummy.norton_value_key(:time2)) }.to_i
-        expect(val).to eq(t.to_i)
+        value_from_redis = Norton.redis.with do |conn|
+          conn.get(dummy.norton_value_key(:counter1))
+        end
+        expect(value_from_redis).to be(nil)
       end
     end
 
-    it "should not save the default value for counter" do
-      dummy = Dummy.new
-
-      t = Time.now
+    context "when the type is :timestamp" do
+      context "when the attribute doesn't allow nil" do
+        it "saves the default value in redis if no value in redis" do
+          allow(dummy).to receive(:time1_default_value) { 1234 }
 
-      Timecop.freeze(t) do
-        values = dummy.norton_mget(:counter1)
-        expect(values[:counter1]).to eq(0)
+          dummy.norton_mget(:time1)
 
-        # Test value directly from Redis
-        expect(Norton.redis.with { |conn| conn.get(dummy.norton_value_key(:counter1)) }).to be_nil
+          value_from_redis = Norton.redis.with do |conn|
+            conn.get(dummy.norton_value_key(:time1))
+          end.to_i
+          expect(value_from_redis).to eq(1234)
+        end
       end
-    end
 
-    it "should return nil if the norton value is not defined" do
-      dummy = Dummy.new
+      context "when the attribute allow nil" do
+        it "doesn't save the default value in redis if no value in redis" do
+          allow(dummy).to receive(:time2_default_value) { nil }
 
-      values = dummy.norton_mget(:time3)
+          dummy.norton_mget(:time2)
 
-      expect(values).to include(:time3)
-      expect(values[:time3]).to be_nil
+          expect(
+            Norton.redis.with { |conn| conn.exists(dummy.norton_value_key(:time2)) }
+          ).to eq(false)
+        end
+      end
     end
   end
 end

data/spec/norton/timestamp_spec.rb

@@ -4,8 +4,8 @@ class Dummy
   include Norton::Timestamp
 
   timestamp :born_at
+  timestamp :thirteen_ts, :digits => 13
   timestamp :first_kissed_at, :allow_nil => true
-  # timestamp :graduated_at, before_save: -> { title_changed? || content_changed? }
 
   def id
     @id ||= Random.rand(10000)
@@ -13,59 +13,102 @@ class Dummy
 end
 
 describe Norton::Timestamp do
-  describe ".timestamp" do
-    it "should add a class method timestamp to the class" do
-      expect(Dummy).to respond_to(:timestamp)
-    end
+  let(:dummy) { Dummy.new }
+
+  it "responds to methods" do
+    expect(dummy.respond_to?(:born_at)).to be(true)
+    expect(dummy.respond_to?(:born_at_default_value)).to be(true)
+    expect(dummy.respond_to?(:touch_born_at)).to be(true)
+    expect(dummy.respond_to?(:remove_born_at)).to be(true)
+  end
 
-    it 'should create timestamp accessors and touch method' do
-      dummy = Dummy.new
+  describe "#born_at" do
+    it "returns the timestamp correctly" do
+      Norton.redis.with do |conn|
+        conn.set(dummy.norton_value_key(:born_at), 123)
+      end
 
-      expect(dummy).to respond_to(:born_at)
-      expect(dummy).to respond_to(:touch_born_at)
+      expect(dummy.born_at).to eq(123)
+      expect(dummy.instance_variable_get(:@born_at)).to eq(123)
     end
 
-    it "should create remove method" do
-      dummy = Dummy.new
-      expect(dummy).to respond_to(:remove_born_at)
+    it "returns default timestamp if no value in norton" do
+      allow(dummy).to receive(:born_at_default_value) { 456 }
+      dummy.born_at
+
+      value = Norton.redis.with do |conn|
+        conn.get(dummy.norton_value_key(:born_at))
+      end
+      expect(value.to_i).to eq(456)
     end
   end
 
-  describe "#touch_born_at" do
-    it 'should set timestamp in redis' do
-      dummy = Dummy.new
-      dummy.touch_born_at
+  describe "#born_at_default_value" do
+    it "returns nil if the timestamp allow nil" do
+      expect(dummy.first_kissed_at_default_value).to eq(nil)
+    end
 
-      Norton.redis.with do |conn|
-        born_at = conn.get("#{Dummy.to_s.pluralize.downcase}:#{dummy.id}:born_at")
-        expect(born_at.to_i).to be > 0
+    it "returns the current time as timestamp" do
+      Timecop.freeze(Time.current) do
+        expect(dummy.born_at_default_value).to eq(Time.current.to_i)
+      end
+    end
+
+    it "returns the current time as 13 digit timestamp" do
+      Timecop.freeze(Time.current) do
+        expect(dummy.thirteen_ts_default_value).to eq((Time.current.to_f * 1000).to_i)
       end
     end
   end
 
-  describe "#born_at" do
-    it 'should get the timestamp' do
-      dummy = Dummy.new
-      dummy.touch_born_at
-      expect(dummy.born_at).not_to be_nil
-      expect(dummy.born_at).to be_a(Fixnum)
+  describe "#touch_born_at" do
+    it "sets the timestamp to the current time" do
+      Timecop.freeze(Time.current) do
+        dummy.touch_born_at
+
+        expect(
+          Norton.redis.with { |conn| conn.get(dummy.norton_value_key(:born_at)) }.to_i
+        ).to eq(Time.current.to_i)
+      end
     end
 
-    it "should get current time as a default if timestamp is not touched" do
-      dummy = Dummy.new
-      t = Time.now
+    it "sets the timestamp to the current time as 13 digit timestamp" do
+      Timecop.freeze(Time.current) do
+        dummy.touch_thirteen_ts
+
+        expect(
+          Norton.redis.with { |conn| conn.get(dummy.norton_value_key(:thirteen_ts)) }.to_i
+        ).to eq((Time.current.to_f * 1000).to_i)
+      end
+    end
 
-      Timecop.freeze(t) do
-        expect(dummy.born_at).to eq(t.to_i)
-        expect(dummy.born_at).to eq(t.to_i)
+    it "sets the instance variable named by timestamp" do
+      Timecop.freeze(Time.current) do
+        dummy.touch_born_at
+        expect(dummy.instance_variable_get(:@born_at)).to eq(Time.current.to_i)
       end
     end
   end
 
-  describe "#first_kissed_at" do
-    it "should return nil if not set before because it allows nil" do
-      dummy = Dummy.new
-      expect(dummy.first_kissed_at).to be_nil
+  describe "#remove_born_at" do
+    it "deletes the timestamp in the redis" do
+      dummy.touch_born_at
+      expect(
+        Norton.redis.with { |conn| conn.exists(dummy.norton_value_key(:born_at)) }
+      ).to be(true)
+
+      dummy.remove_born_at
+      expect(
+        Norton.redis.with { |conn| conn.exists(dummy.norton_value_key(:born_at)) }
+      ).to be(false)
+    end
+
+    it "removes the instance variable named by timestamp" do
+      dummy.touch_born_at
+      expect(dummy.instance_variable_defined?(:@born_at)).to be(true)
+
+      dummy.remove_born_at
+      expect(dummy.instance_variable_defined?(:@born_at)).to be(false)
     end
   end
 end

data/spec/norton_spec.rb

@@ -8,102 +8,97 @@ describe Norton do
     end
   end
 
-  describe "mget" do
-    class Foobar
+  describe ".mget" do
+    class Dummy
       include Norton::Counter
       include Norton::Timestamp
+      include Norton::HashMap
 
-      counter :test_counter
-      timestamp :test_timestamp
-
-      def initialize(id)
-        @id = id
-      end
+      counter   :counter1
+      timestamp :time1
+      hash_map  :map1
 
       def id
-        @id
+        @id ||= Random.rand(10000)
       end
     end
 
-    it "should get the values correctly" do
-      foobar1 = Foobar.new(SecureRandom.hex(2))
-      foobar2 = Foobar.new(SecureRandom.hex(2))
-
-      Random.rand(100).times { foobar1.incr_test_counter }
-      foobar1.touch_test_timestamp
-
-      sleep(2)
-
-      Random.rand(100).times { foobar2.incr_test_counter }
-      foobar2.touch_test_timestamp
+    let(:dummy) { Dummy.new }
 
-      vals = Norton.mget([foobar1, foobar2], [:test_counter, :test_timestamp])
-
-      expect(vals).to include("foobars:#{foobar1.id}:test_counter" => foobar1.test_counter)
-      expect(vals).to include("foobars:#{foobar1.id}:test_timestamp" => foobar1.test_timestamp)
-      expect(vals).to include("foobars:#{foobar2.id}:test_counter" => foobar2.test_counter)
-      expect(vals).to include("foobars:#{foobar2.id}:test_timestamp" => foobar2.test_timestamp)
+    context "when the field isn't defined" do
+      it "doesn't set the instance variable" do
+        Norton.mget([dummy], %i[undefined_field])
+        expect(dummy.instance_variable_defined?(:@undefined_field)).to be(false)
+      end
     end
 
-    it "should get default value correctly if no value in norton redis database" do
-      foobar1 = Foobar.new(SecureRandom.hex(2))
-      foobar2 = Foobar.new(SecureRandom.hex(2))
+    context "when the type isn't in the [:counter, :timestamp]" do
+      it "doesn't set the instance variable" do
+        Norton.mget([dummy], %i[map1])
+        expect(dummy.instance_variable_defined?(:@map1)).to be(false)
+      end
+    end
 
-      t = Time.now
+    context "when the type is in the [:counter, :timestamp]" do
+      it "returns norton values correctly from redis" do
+        Norton.redis.with do |conn|
+          conn.set(dummy.norton_value_key(:counter1), 2)
+          conn.set(dummy.norton_value_key(:time1), 1234)
+        end
 
-      Timecop.freeze(t) do
-        foobar1.incr_test_counter
-        foobar2.touch_test_timestamp
+        Norton.mget([dummy], %i[counter1 time1])
+        expect(dummy.instance_variable_get(:@counter1)).to eq(2)
+        expect(dummy.instance_variable_get(:@time1)).to eq(1234)
       end
 
-      sleep(1)
+      it "returns the default value if no value in redis" do
+        allow(dummy).to receive(:counter1_default_value) { 99 }
+        allow(dummy).to receive(:time1_default_value) { 1234 }
 
-      t2 = Time.now
-
-      vals = Timecop.freeze(t2) do
-        Norton.mget([foobar1, foobar2], [:test_counter, :test_timestamp])
+        Norton.mget([dummy], %i[counter1 time1])
+        expect(dummy.instance_variable_get(:@counter1)).to eq(99)
+        expect(dummy.instance_variable_get(:@time1)).to eq(1234)
       end
-
-      expect(vals).to include("foobars:#{foobar1.id}:test_counter" => 1)
-      expect(vals).to include("foobars:#{foobar1.id}:test_timestamp" => t2.to_i)
-      expect(vals).to include("foobars:#{foobar2.id}:test_counter" => 0)
-      expect(vals).to include("foobars:#{foobar2.id}:test_timestamp" => t.to_i)
     end
 
-    it "should return nil for undefined norton values" do
-      foobar1 = Foobar.new(SecureRandom.hex(2))
-      foobar2 = Foobar.new(SecureRandom.hex(2))
+    context "when the type is :counter" do
+      it "doesn't save the default value in redis if no value in redis" do
+        allow(dummy).to receive(:counter1_default_value) { 99 }
 
-      t = Time.now
+        Norton.mget([dummy], %i[counter1])
 
-      Timecop.freeze(t) do
-        foobar1.incr_test_counter
-        foobar2.touch_test_timestamp
+        value_from_redis = Norton.redis.with do |conn|
+          conn.get(dummy.norton_value_key(:counter1))
+        end
+        expect(value_from_redis).to be(nil)
       end
-
-      vals = Norton.mget([foobar1, foobar2], [:test_counter, :test_timestamp, :test_foobar])
-
-      expect(vals).to include("foobars:#{foobar1.id}:test_counter" => 1)
-      expect(vals).to include("foobars:#{foobar2.id}:test_timestamp" => t.to_i)
-      expect(vals).to include("foobars:#{foobar1.id}:test_foobar" => nil)
-      expect(vals).to include("foobars:#{foobar2.id}:test_foobar" => nil)
     end
 
-    it "returns the default value when the field value is nil" do
-      object = Foobar.new(99)
-      allow(object).to receive(:test_timestamp_default_value) { 22 }
+    context "when the type is :timestamp" do
+      context "when the attribute doesn't allow nil" do
+        it "saves the default value in redis if no value in redis" do
+          allow(dummy).to receive(:time1_default_value) { 1234 }
 
-      ret = Norton.mget([object], %i[test_timestamp])
-      expect(ret["foobars:99:test_timestamp"]).to eq(22)
-    end
+          dummy.norton_mget(:time1)
+
+          value_from_redis = Norton.redis.with do |conn|
+            conn.get(dummy.norton_value_key(:time1))
+          end.to_i
+          expect(value_from_redis).to eq(1234)
+        end
+      end
 
-    it "sets the default value in redis if the `Timestamp` field value is nil" do
-      object = Foobar.new(99)
-      allow(object).to receive(:test_timestamp_default_value) { 22 }
+      context "when the attribute allow nil" do
+        it "doesn't save the default value in redis if no value in redis" do
+          allow(dummy).to receive(:time2_default_value) { nil }
 
-      Norton.mget([object], %i[test_timestamp])
+          dummy.norton_mget(:time2)
 
-      expect(Norton.redis.with { |conn| conn.get("foobars:99:test_timestamp") }.to_i).to eq(22)
+          expect(
+            Norton.redis.with { |conn| conn.exists(dummy.norton_value_key(:time2)) }
+          ).to eq(false)
+        end
+      end
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: norton
 version: !ruby/object:Gem::Version
-  version: 0.0.26
+  version: 0.0.28
 platform: ruby
 authors:
 - Larry Zhao
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-06-29 00:00:00.000000000 Z
+date: 2017-08-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis
@@ -189,6 +189,7 @@ files:
 - ".gitignore"
 - ".rspec"
 - ".travis.yml"
+- CHANGLOG.md
 - Gemfile
 - LICENSE
 - LICENSE.txt
@@ -230,7 +231,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.11
+rubygems_version: 2.6.12
 signing_key: 
 specification_version: 4
 summary: Provide simple helpers on persist values in redis for performance. Works