norton 0.0.24 → 0.0.26

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 47f5a6a213e297cec27645a41ff453ae1b7d4bfd
-  data.tar.gz: 37b3492ec453174d6bb8993ddf835ae2af2a43b4
+  metadata.gz: dcc25c436cc01399c68e17739b2181d7298e5a05
+  data.tar.gz: 9add33b7a73eb52e1cceaceecee1728db377ae15
 SHA512:
-  metadata.gz: cd5c343f935788a653d31e65b8f94107353df0121ced3610cc65613782fdc462450b05437a06c613f1dfd6c84dc6941dcf90119ccb66f0e1dbd81ce12ce6ca47
-  data.tar.gz: 12969d600acc46904a4680e49cf62f3acaff0243970449358d98619a9cf4e9e08f441f6c4cb86ddb057c81b56312f9cea06780e7b51bfa8ebde631cd5ce29a7f
+  metadata.gz: e8dd9328148d9ec90be45726443cdadabbf99de363c11a9680897f53886f6cf5aabe8b6de429c9c92e28986b8ee4d03f95c1a63e0543116f3c7146e3725ac8ee
+  data.tar.gz: 3e7b992f5406d3c3876f1e065f108a5d3c0bc690bb90429d85f6709980c9d14a02abd1f88252cce62ab9d39f01ef482b94a950a8dc01fb2d8513ddbfb9df9c05

data/.codeclimate.yml

@@ -0,0 +1,16 @@
+---
+engines:
+  duplication:
+    enabled: true
+    config:
+      languages:
+      - ruby
+  fixme:
+    enabled: true
+  rubocop:
+    enabled: true
+ratings:
+  paths:
+  - "**.rb"
+exclude_paths:
+- spec/

data/.travis.yml

@@ -7,7 +7,8 @@ rvm:
   - 2.3.0
 
 script:
-  - RAILS_ENV=test bundle exec rake
+  - bundle exec rake
+  - bundle exec codeclimate-test-reporter
 
 notifications:
   email: false

data/Gemfile

@@ -1,4 +1,9 @@
 source "https://rubygems.org"
 
-# Specify your gem's dependencies in norton.gemspec
+group :test do
+  gem "simplecov", "~> 0.14", require: false
+  gem "codeclimate-test-reporter", "~> 1.0", require: false
+end
+
+# Specify your gem"s dependencies in norton.gemspec
 gemspec

data/README.md

@@ -1,5 +1,9 @@
 # Norton
 
+[![Build Status](https://travis-ci.org/jianshucom/norton.svg?branch=master)](https://travis-ci.org/jianshucom/norton)
+[![Code Climate](https://codeclimate.com/github/jianshucom/norton/badges/gpa.svg)](https://codeclimate.com/github/jianshucom/norton)
+[![Test Coverage](https://codeclimate.com/github/jianshucom/norton/badges/coverage.svg)](https://codeclimate.com/github/jianshucom/norton/coverage)
+
 ## Installation
 
 Add this line to your application's Gemfile:
@@ -16,7 +20,7 @@ Or install it yourself as:
 
 ## Setup
 
-You need to setup Norton with a redis connection, 
+You need to setup Norton with a redis connection,
 
 `Norton.setup url: <some redis connection url> `
 
@@ -33,7 +37,7 @@ Simply include `Norton::Counter` in your model, and define a counter.
 ```
 class User < ActiveRecord::Base
   include Norton::Counter
-  
+
   counter :total_likes_count
 end
 ```
@@ -48,7 +52,7 @@ You could also give a reset block:
 ```
 class User < ActiveRecord::Base
   include Norton::Counter
-  
+
   counter :total_likes_count do
     self.likes.count
   end
@@ -65,7 +69,7 @@ Simply include `Norton::Timestamp` in your model, and define a timestamp.
 ```
 class Note < ActiveRecord::Base
   include Norton::Timestamp
-  
+
   timestamp :content_updated_at
 end
 ```
@@ -79,7 +83,7 @@ You could specify callbacks along with condition Procs of when to touch the time
 ```
 class Note < ActiveRecord::Base
   include Norton::Timestamp
-  
+
   timestamp :content_updated_at, before_save: Proc.new { title_changed? || content_changed? }
 end
 ```

data/lib/norton/counter.rb

@@ -15,39 +15,46 @@ module Norton
       #
       # @return [type] [description]
       def counter(name, options={}, &blk)
+        self.register_norton_value(name, :counter)
+
         define_method(name) do
           Norton.redis.with do |conn|
-            conn.get(self.norton_redis_key(name)).try(:to_i) || 0
+            conn.get(self.norton_value_key(name)).try(:to_i) || send("#{name}_default_value".to_sym)
           end
         end
 
+        define_method("#{name}_default_value") do
+          0
+        end
+        send(:private, "#{name}_default_value".to_sym)
+
         define_method("incr_#{name}") do
           Norton.redis.with do |conn|
-            conn.incr(self.norton_redis_key(name))
+            conn.incr(self.norton_value_key(name))
           end
         end
 
         define_method("decr_#{name}") do
           Norton.redis.with do |conn|
-            conn.decr(self.norton_redis_key(name))
+            conn.decr(self.norton_value_key(name))
           end
         end
 
         define_method("incr_#{name}_by") do |increment|
           Norton.redis.with do |conn|
-            conn.incrby(self.norton_redis_key(name), increment)
+            conn.incrby(self.norton_value_key(name), increment)
           end
         end
 
         define_method("decr_#{name}_by") do |decrement|
           Norton.redis.with do |conn|
-            conn.decrby(self.norton_redis_key(name), decrement)
+            conn.decrby(self.norton_value_key(name), decrement)
           end
         end
 
         define_method("#{name}=") do |v|
           Norton.redis.with do |conn|
-            conn.set(self.norton_redis_key(name), v)
+            conn.set(self.norton_value_key(name), v)
           end
         end
 
@@ -55,13 +62,13 @@ module Norton
           count = instance_eval(&blk)
 
           Norton.redis.with do |conn|
-            conn.set(self.norton_redis_key(name), count)
+            conn.set(self.norton_value_key(name), count)
           end
         end
 
         define_method("remove_#{name}") do
           Norton.redis.with do |conn|
-            conn.del(self.norton_redis_key(name))
+            conn.del(self.norton_value_key(name))
           end
         end
         send(:after_destroy, "remove_#{name}".to_sym) if respond_to? :after_destroy

data/lib/norton/hash_map.rb

@@ -8,10 +8,12 @@ module Norton
 
     module ClassMethods
       def hash_map(name)
+        self.register_norton_value(name, :hash_map)
+
         define_method(name) do
           instance_variable_get("@#{name}") ||
             instance_variable_set("@#{name}",
-              Norton::Objects::Hash.new(self.norton_redis_key(name))
+              Norton::Objects::Hash.new(self.norton_value_key(name))
             )
         end
 

data/lib/norton/helper.rb

@@ -2,6 +2,51 @@ module Norton
   module Helper
     extend ActiveSupport::Concern
 
+    included do
+      instance_variable_set(:@norton_values, {})
+    end
+
+    module ClassMethods
+      attr_reader :norton_values
+
+
+      #
+      # 当前类是否定义了某个 Norton Value
+      #
+      # @param [String/Symbol] name
+      #
+      # @return [Boolean]
+      #
+      def norton_value_defined?(name)
+        self.norton_values.has_key?(name.to_sym)
+      end
+
+      #
+      # 返回当前类定义的某个 Norton Value 的类型
+      #
+      # @param [String] name
+      #
+      # @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
+      end
+    end
+
     #
     # Prefix of Redis Key of Norton value, consists with Class name string in plural form
     # and Instance id.
@@ -34,28 +79,44 @@ module Norton
     #
     # @return [String]
     #
-    def norton_redis_key(name)
+    def norton_value_key(name)
       "#{self.norton_prefix}:#{name}"
     end
 
     #
-    # 批量取出当前对象的多个 Norton value
+    # 批量取出当前对象的多个 Norton value, 仅仅支持 counter / timestamp
     #
     # @param [Array] *value_keys 直接传入需要的值的 key，例如: :key1, :key2, :key3
     #
     # @return [Hash]
     #
-    def norton_vals(*names)
+    def norton_mget(*names)
       ret = {}
 
-      redis_keys = names.map { |n| self.norton_redis_key(n) }
+      redis_keys = names.map { |n| self.norton_value_key(n) }
 
-      redis_values = Norton.redis.with do |conn|
-        conn.mget(redis_keys)
-      end
+      Norton.redis.with do |conn|
+        # mget 一次取出所有的值
+        redis_values = conn.mget(redis_keys)
+
+        # 组装结果 Hash
+        names.each_with_index do |n, index|
+          val = redis_values[index].try(:to_i)
+
+          # 如果返回值为 nil 并且定义了这个 norton value
+          # 那么获取返回值
+          if val.nil? && self.class.norton_value_defined?(n)
+            val = send("#{n}_default_value".to_sym)
+
+            # 如果返回值不为空，将默认值存入 SSDB
+            # 并且当前 Value 是 `:timestamp`
+            if !val.nil? && self.class.norton_value_type(n) == :timestamp
+              conn.set(self.norton_value_key(n), val)
+            end
+          end
 
-      names.each_with_index do |n, index|
-        ret[n] = redis_values[index].try(:to_i)
+          ret[n] = val
+        end
       end
 
       ret

data/lib/norton/timed_value.rb

@@ -16,11 +16,11 @@ module Norton
         # Define getter
         define_method(name) do
           Norton.redis.with do |conn|
-            v = conn.get(self.norton_redis_key(name))
+            v = conn.get(self.norton_value_key(name))
 
             if v.nil?
               v = instance_eval(&blk)
-              conn.setex(self.norton_redis_key(name), options[:ttl], v)
+              conn.setex(self.norton_value_key(name), options[:ttl], v)
             end
 
             v
@@ -30,7 +30,7 @@ module Norton
         define_method("reset_#{name}") do
           Norton.redis.with do |conn|
             v = instance_eval(&blk)
-            conn.setex(self.norton_redis_key(name), options[:ttl], v)
+            conn.setex(self.norton_value_key(name), options[:ttl], v)
             v
           end
         end

data/lib/norton/timestamp.rb

@@ -14,27 +14,44 @@ module Norton
       #
       # @return [type] [description]
       def timestamp(name, options={})
+        self.register_norton_value(name, :timestamp)
+
         define_method(name) do
           ts = nil
 
           Norton.redis.with do |conn|
-            ts = conn.get(self.norton_redis_key(name)).try(:to_i)
+            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?
+            end
 
-            if !options[:allow_nil] && ts.nil?
+            ts
+          end
+        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
-              conn.set(self.norton_redis_key(name), ts)
             end
 
             ts
+          else
+            nil
           end
         end
+        send(:private, "#{name}_default_value".to_sym)
 
         define_method("touch_#{name}") do
           Norton.redis.with do |conn|
             if options[:digits].present? && options[:digits] == 13
-              conn.set(self.norton_redis_key(name), (Time.now.to_f * 1000).to_i)
+              conn.set(self.norton_value_key(name), (Time.now.to_f * 1000).to_i)
             else
-              conn.set(self.norton_redis_key(name), Time.now.to_i)
+              conn.set(self.norton_value_key(name), Time.now.to_i)
             end
           end
         end

data/lib/norton/version.rb

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

data/lib/norton.rb

@@ -11,7 +11,10 @@ require "norton/objects/hash"
 require "norton/hash_map"
 
 module Norton
+  SUPPORTED_TYPES = %i(counter timestamp hash_map)
+
   class NilObjectId < StandardError; end
+  class InvalidType < StandardError; end
 
   class << self
     attr_accessor :redis
@@ -28,8 +31,88 @@ module Norton
       timeout = (options[:timeout] || 2).to_i
 
       Norton.redis = ConnectionPool.new(:size => pool_size, :timeout => timeout) do
-        Redis.new(options.slice(:url, :host, :port, :db, :path, :password, :namespace, :ssl_params, :driver))
+        Redis.new(
+          options.slice(:url, :host, :port, :db, :path, :password, :namespace, :ssl_params, :driver)
+        )
+      end
+    end
+
+    #
+    # 为多个 Norton 对象一次性取出多个值
+    #
+    # 从一组相同的对象中，一次性取出多个 Norton 值。
+    #
+    # 例如:
+    #
+    # 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
       end
+
+      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
+      end
+
+      ret
     end
   end
 end

data/spec/norton/hash_map_spec.rb

@@ -11,10 +11,10 @@ class HashMapObject
 end
 
 describe Norton::HashMap do
-  describe "#norton_redis_key" do
+  describe "#norton_value_key" do
     it "generates the correct field key" do
       object = HashMapObject.new
-      expect(object.norton_redis_key(:profile)).to eq("hash_map_objects:99:profile")
+      expect(object.norton_value_key(:profile)).to eq("hash_map_objects:99:profile")
     end
   end
 

data/spec/norton/helper_spec.rb

@@ -3,12 +3,16 @@ require 'spec_helper'
 class Dummy
   include Norton::Counter
   include Norton::Timestamp
+  include Norton::HashMap
 
   counter :counter1
   counter :counter2
   counter :counter3
 
   timestamp :time1
+  timestamp :time2
+
+  hash_map :map1
 
   def id
     @id ||= Random.rand(10000)
@@ -26,12 +30,47 @@ module HolyLight
 end
 
 describe Norton::Helper do
-  describe "#norton_redis_key" 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
+  end
+
+  describe ".norton_value_defined?" do
+    it "should return true for a defined value" do
+      expect(Dummy.norton_value_defined?(:counter1)).to eq(true)
+    end
+
+    it "should return false for a defined 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_redis_key(n)).to eq("dummies:#{dummy.id}:#{n}")
+      expect(dummy.norton_value_key(n)).to eq("dummies:#{dummy.id}:#{n}")
     end
 
     it "should raise `Norton::NilObjectId` if id returns nil" do
@@ -54,11 +93,11 @@ describe Norton::Helper do
     end
   end
 
-  describe "#norton_vals" do
-    it "should respond to `:norton_vals`" do
+  describe "#norton_mget" do
+    it "should respond to `:norton_mget`" do
       dummy = Dummy.new
 
-      expect(dummy).to respond_to(:norton_vals)
+      expect(dummy).to respond_to(:norton_mget)
     end
 
     it "should return the specific values" do
@@ -70,7 +109,7 @@ describe Norton::Helper do
 
       dummy.touch_time1
 
-      values = dummy.norton_vals(:counter1, :time1)
+      values = dummy.norton_mget(:counter1, :time1)
 
       expect(values).to include(:counter1, :time1)
       expect(values.size).to eq(2)
@@ -78,22 +117,63 @@ describe Norton::Helper do
       expect(values[:time1]).to eq(dummy.time1)
     end
 
-    it "should return nil if the specific key does not exist" do
+    it "should default value if the value of does not exist" do
       dummy = Dummy.new
 
       dummy.counter1 = 10
       dummy.counter2 = 15
-      dummy.counter3 = 100
 
       dummy.touch_time1
 
-      values = dummy.norton_vals(:counter1, :counter2, :time2)
+      t = Time.now
 
-      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 be_nil
+      Timecop.freeze(t) do
+        values = dummy.norton_mget(:counter1, :counter2, :time2)
+
+        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)
+      end
+    end
+
+    it "should save the default value for timestamp" do
+      dummy = Dummy.new
+
+      t = Time.now
+
+      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)
+      end
+    end
+
+    it "should not save the default value for counter" do
+      dummy = Dummy.new
+
+      t = Time.now
+
+      Timecop.freeze(t) do
+        values = dummy.norton_mget(:counter1)
+        expect(values[:counter1]).to eq(0)
+
+        # Test value directly from Redis
+        expect(Norton.redis.with { |conn| conn.get(dummy.norton_value_key(:counter1)) }).to be_nil
+      end
+    end
+
+    it "should return nil if the norton value is not defined" do
+      dummy = Dummy.new
+
+      values = dummy.norton_mget(:time3)
+
+      expect(values).to include(:time3)
+      expect(values[:time3]).to be_nil
     end
   end
 end

data/spec/norton_spec.rb

@@ -7,4 +7,103 @@ describe Norton do
       expect(Norton.redis).not_to be_nil
     end
   end
+
+  describe "mget" do
+    class Foobar
+      include Norton::Counter
+      include Norton::Timestamp
+
+      counter :test_counter
+      timestamp :test_timestamp
+
+      def initialize(id)
+        @id = id
+      end
+
+      def id
+        @id
+      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
+
+      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)
+    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))
+
+      t = Time.now
+
+      Timecop.freeze(t) do
+        foobar1.incr_test_counter
+        foobar2.touch_test_timestamp
+      end
+
+      sleep(1)
+
+      t2 = Time.now
+
+      vals = Timecop.freeze(t2) do
+        Norton.mget([foobar1, foobar2], [:test_counter, :test_timestamp])
+      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))
+
+      t = Time.now
+
+      Timecop.freeze(t) do
+        foobar1.incr_test_counter
+        foobar2.touch_test_timestamp
+      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 }
+
+      ret = Norton.mget([object], %i[test_timestamp])
+      expect(ret["foobars:99:test_timestamp"]).to eq(22)
+    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 }
+
+      Norton.mget([object], %i[test_timestamp])
+
+      expect(Norton.redis.with { |conn| conn.get("foobars:99:test_timestamp") }.to_i).to eq(22)
+    end
+  end
 end

data/spec/spec_helper.rb

@@ -1,9 +1,12 @@
+require "simplecov"
 require "active_record"
 require "nulldb"
 require "norton"
 require "rspec"
 require "timecop"
 
+SimpleCov.start
+
 RSpec.configure do |config|
   config.expect_with :rspec do |expectations|
     expectations.syntax = :expect

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: norton
 version: !ruby/object:Gem::Version
-  version: 0.0.24
+  version: 0.0.26
 platform: ruby
 authors:
 - Larry Zhao
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-06-24 00:00:00.000000000 Z
+date: 2017-06-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis
@@ -185,6 +185,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".codeclimate.yml"
 - ".gitignore"
 - ".rspec"
 - ".travis.yml"