cache_crispies 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bed703f9038261d6ff63e08465e7c0dccea1bcb6e2cb583de3ab154da562ef8f
-  data.tar.gz: ed55298237e61b9c6995a0194c61cd6ec221ea3cd62be176afa8842cb9d28c50
+  metadata.gz: af451e5837f96664e141a147df118fbfffb7ee4fedc71cd5e6c34438b9069461
+  data.tar.gz: ffe23f3217c50b5c6bbbd183127a2274b6c4afb59ad93e50a271c880d20968f4
 SHA512:
-  metadata.gz: e6897a7621e75851e7d9b2092674a44ed0ff42f328c61876b9de82dfc984c1eb2a7379dbe60f336659552be6445798063a1df83941fab55aeb0537a67fea5718
-  data.tar.gz: 0a9ac99db021a8e5ac1d06547d55c84e346aa550f020598f716993a5b783c2f2f8bcf002fda92d113f1864da2083f03719a5a240ae3e8dbebf3e24df01e1a543
+  metadata.gz: e8208c9ef13c4f66e9d64c7b8a5394e7d2907b894ff4ca6617357ca785ede999048d3ef4ffc00d900a30e5ac284401a5b145fb2271764f878d16603017ac08d1
+  data.tar.gz: 167cf43b28151ec4d6c65c0badfcbe73a871f7a102bc916f04eb0e889069843e518db1a608da31c854096a60843bd50a69ab99a2b4b784a89ce1d5ecd5e549fe

data/lib/cache_crispies.rb

@@ -1,12 +1,20 @@
+# frozen_string_literal: true
+
 require 'active_support/dependencies'
 require 'oj'
 
+# The top level namespace module for the gem
 module CacheCrispies
-  CACHE_KEY_PREFIX = 'cache-crispies'.freeze
-  CACHE_KEY_SEPARATOR = '+'.freeze
+  # A prefix used in building cache key. This should be extra insurance against
+  # key conflicts and also provides an easy way to search for keys in Redis.
+  CACHE_KEY_PREFIX = 'cache-crispies'
+
+  # The string to use to join parts of the cache keys together
+  CACHE_KEY_SEPARATOR = '+'
 
   require 'cache_crispies/version'
 
+  # Use autoload for better Rails development
   autoload :Attribute,    'cache_crispies/attribute'
   autoload :Base,         'cache_crispies/base'
   autoload :Collection,   'cache_crispies/collection'
@@ -15,4 +23,4 @@ module CacheCrispies
   autoload :Memoizer,     'cache_crispies/memoizer'
   autoload :Controller,   'cache_crispies/controller'
   autoload :Plan,         'cache_crispies/plan'
-end
+end

data/lib/cache_crispies/attribute.rb

@@ -1,8 +1,29 @@
+# frozen_string_literal: true
+
 module CacheCrispies
+  # Reperesents a single serialized attribute in a serializer. It's generated
+  # by a call to either {CacheCrispies::Base.serialize} or
+  # {CacheCrispies::Base.merge}.
   class Attribute
-    class InvalidCoersionType < ArgumentError; end
+    # Represents an invalid option passed in the to: argument
+    class InvalidCoercionType < ArgumentError; end
 
-    def initialize(key, from: nil, with: nil, to: nil, nesting: [], conditions: [])
+    # Initializes a new CacheCrispies::Attribute instance
+    #
+    # @param key [Symbol] the JSON key for this attribute
+    # @param from [Symbol] the method on the model to call to get the value
+    # @param with [CacheCrispies::Base] a serializer to use to serialize the
+    # @param to [Class, Symbol] the data type to coerce the value into
+    # @param nesting [Array<Symbol>] the JSON keys this attribute will be
+    #    nested inside
+    # @param conditions [Array<CacheCrispies::Condition>] the show_if condition
+    #   blocks this attribute is nested inside. These will be evaluated for
+    #   thruthiness and must all be true for this attribute to reneder.
+    #   argument's value
+    def initialize(
+      key,
+      from: nil, with: nil, to: nil, nesting: [], conditions: []
+    )
       @key = key
       @method_name = from || key || :itself
       @serializer = with
@@ -11,8 +32,22 @@ module CacheCrispies
       @conditions = Array(conditions)
     end
 
-    attr_reader :method_name, :key, :serializer, :coerce_to, :nesting, :conditions
+    attr_reader(
+      :method_name,
+      :key,
+      :serializer,
+      :coerce_to,
+      :nesting,
+      :conditions
+    )
 
+    # Gets the value of the attribute for the given model and options
+    #
+    # @param model [Object] typically ActiveRecord::Base, but could be anything
+    # @param options [Hash] any optional values from the serializer instance
+    # @return the value for the attribute for the given model and options
+    # @raise [InvalidCoercionType] when an invalid argument is passed in the
+    #   to: argument
     def value_for(model, options)
       value = model.public_send(method_name)
 
@@ -51,7 +86,7 @@ module CacheCrispies
         !!value
       else
         raise(
-          InvalidCoersionType,
+          InvalidCoercionType,
           "#{coerce_to} has no registered coercion strategy"
         )
       end
@@ -63,4 +98,4 @@ module CacheCrispies
       ).public_send(method_name)
     end
   end
-end
+end

data/lib/cache_crispies/base.rb

@@ -1,50 +1,109 @@
+# frozen_string_literal: true
+
 require 'digest'
 require 'rails'
 
 module CacheCrispies
+  # The Base class that all serializer classes should inherit from
   class Base
     attr_reader :model, :options
 
+    # Define class-level instance variables and their default values when the
+    # class is inherited by another class. This is not meant to be called
+    # directly. It is called internally by Ruby.
+    #
+    # @param other [Class] the inheriting child class
+    # @return [void]
+    def self.inherited(other)
+      other.instance_variable_set(:@attributes, [])
+      other.instance_variable_set(:@nesting, [])
+      other.instance_variable_set(:@conditions, [])
+    end
+
+    class << self
+      attr_reader :attributes
+    end
+    delegate :attributes, to: :class
+
+    # Initializes a new instance of CacheCrispies::Base, or really, it should
+    # always be a subclass of CacheCrispies::Base.
+    #
+    # @param model [Object] typically ActiveRecord::Base, but could be anything
+    # @param options [Hash] any optional custom values you want to be
+    #   accessible in your subclass.
     def initialize(model, options = {})
       @model = model
       @options = options
     end
 
+    # Renders the serializer instance to a JSON-ready Hash
+    #
+    # @return [Hash] a JSON-ready hash
     def as_json
       HashBuilder.new(self).call
     end
 
+    # Whether or not this serializer class should allow caching of results.
+    # It is set to false by default, but can be overridden in child classes.
+    #
+    # @return [Boolean]
     def self.do_caching?
       false
     end
 
+    # A JSON key to use as a root key on a non-collection serializable. by
+    # default it's the name of the class without the "Serializer" part. But it
+    # can be overridden in a subclass to be anything.
+    #
+    # @return [Symbol] a symbol to be used as a key for a JSON-ready Hash
     def self.key
       to_s.demodulize.chomp('Serializer').underscore.to_sym
     end
 
+    # A JSON key to use as a root key on a collection-type serializable. By
+    # deafult it's the plural version of .key, but it can be overridden in a
+    # subclass to be anything.
+    #
+    # @return [Symbol] a symbol to be used as a key for a JSON-ready Hash
     def self.collection_key
       return nil unless key
 
       key.to_s.pluralize.to_sym
     end
 
-    # Can be overridden in subclasses
-    # options: Hash of the same options that would be passed to the
-    #          individual serializer instances
+    # An array of strings that should be added to the cache key for an instance
+    # of this serializer. Typically you'd add in the #cache_key or string value
+    # for any extra models or data passed in through the options hash here. But
+    # it could also contain any custom logic about how to construct a cache
+    # key. This method is meant to be overridden in subclasses.
+    #
+    # @example cache based off models provided in options
+    #   def self.cache_key_addons(options)
+    #     [options[:current_user].cache_key]
+    #   end
+    #
+    # @example time-based caching
+    #   def self.cache_key_addons(_options)
+    #     [Date.today.to_s]
+    #   end
+    #
+    # @param options [Hash] the options hash passed to the serializer, will be
+    # passed in here as well so you can refernce it if needed.
+    # @return [Array<String>]
     def self.cache_key_addons(_options = {})
       []
     end
 
+    # Return a cache key string for the serializer class to be included in the
+    # cache key for the instances. The key includes the name of the class, and
+    # a digest of the contents of the main class file.
+    #
+    # @return [String] a cache key for the class
     def self.cache_key_base
       # TODO: we may need to get a cache key from nested serializers as well :(
       @cache_key_base ||= "#{self}-#{file_hash}"
     end
 
-    def self.attributes
-      @attributes || []
-    end
-    delegate :attributes, to: :class
-
     private
 
     def self.file_hash
@@ -63,7 +122,6 @@ module CacheCrispies
     private_class_method :path
 
     def self.nest_in(key, &block)
-      @nesting ||= []
       @nesting << key
 
       block.call
@@ -73,7 +131,6 @@ module CacheCrispies
     private_class_method :nest_in
 
     def self.show_if(condition_proc, &block)
-      @conditions ||= []
       @conditions << Condition.new(condition_proc)
 
       block.call
@@ -83,8 +140,6 @@ module CacheCrispies
     private_class_method :show_if
 
     def self.serialize(*attribute_names, from: nil, with: nil, to: nil)
-      @attributes ||= []
-
       attribute_names.flatten.map { |att| att&.to_sym }.map do |attrib|
         current_nesting = Array(@nesting).dup
         current_conditions = Array(@conditions).dup
@@ -107,4 +162,4 @@ module CacheCrispies
     end
     private_class_method :merge
   end
-end
+end

data/lib/cache_crispies/collection.rb

@@ -1,13 +1,28 @@
+# frozen_string_literal: true
+
 require 'rails'
 
 module CacheCrispies
+  # Handles rendering and possibly caching a collection of models using a
+  #   Serializer
   class Collection
+    # Initializes a new instance of CacheCrispies::Collection
+    #
+    # @param colleciton [Object] typically an enumerable containing instances of
+    #   ActiveRecord::Base, but could be any enumerable
+    # @param serializer [CacheCrispies::Base] a class inheriting from
+    #   CacheCrispies::Base
+    # @param options [Hash] any optional values from the serializer instance
     def initialize(collection, serializer, options = {})
       @collection = collection
       @serializer = serializer
       @options = options
     end
 
+    # Renders the collection to a JSON-ready Hash trying to cache the hash
+    #   along the way
+    #
+    # @return [Hash] the JSON-ready Hash
     def as_json
       if serializer.do_caching? && collection.respond_to?(:cache_key)
         cached_json
@@ -40,4 +55,4 @@ module CacheCrispies
       end
     end
   end
-end
+end

data/lib/cache_crispies/condition.rb

@@ -1,17 +1,29 @@
+# frozen_string_literal: true
+
 module CacheCrispies
-  # Represents an instance of a conditional built by a show_if call
+  # Represents an instance of a conditional built by a
+  # {CacheCrispies::Base.show_if} call
   class Condition
+    # Returns a new instance of Condition
+    #
+    # @param block [Proc] a block containing the logic for the condition
     def initialize(block)
       @block = block
     end
 
-    # Public: A system-wide unique ID used for memoizaiton
-    # Returns an Integer
+    # A system-wide unique ID used for memoizaiton
+    #
+    # @eturn [Integer] the unique ID for this condition
     def uid
       # Just reusing the block's object_id seems to make sense
       block.object_id
     end
 
+    # Test the truthiness of the condition against a model and options
+    #
+    # @param model [Object] typically ActiveRecord::Base, but could be anything
+    # @param options [Hash] any optional values from the serializer instance
+    # @return [Boolean] the condition's truthiness
     def true_for?(model, options = {})
       !!case block.arity
         when 0
@@ -27,4 +39,4 @@ module CacheCrispies
 
     attr_reader :block
   end
-end
+end

data/lib/cache_crispies/controller.rb

@@ -1,9 +1,24 @@
+# frozen_string_literal: true
+
 module CacheCrispies
+  # A Rails concern designed to be used in Rails controllers to provide access to
+  # the #cache_render method
   module Controller
     extend ActiveSupport::Concern
 
+    # The serialization mode that should be used with the oj gem
     OJ_MODE = :rails
 
+    # Renders the provided cacheable object to JSON using the provided
+    # serializer
+    #
+    # @param serializer [CacheCrispies::Base] a class inheriting from
+    #   CacheCrispies::Base
+    # @param cacheable [Object] can be any object. But is typically a Rails
+    #   model inheriting from ActiveRecord::Base
+    # @param options [Hash] any hash of custom options that should be passed
+    #   to the serializer instance
+    # @return [void]
     def cache_render(serializer, cacheable, options = {})
       plan = CacheCrispies::Plan.new(serializer, cacheable, options)
 
@@ -23,4 +38,4 @@ module CacheCrispies
       render json: Oj.dump(plan.wrap(serializer_json), mode: OJ_MODE)
     end
   end
-end
+end

data/lib/cache_crispies/hash_builder.rb

@@ -1,10 +1,20 @@
+# frozen_string_literal: true
+
 module CacheCrispies
+  # Builds out a JSON-ready Hash using the attributes in a Serializer
   class HashBuilder
+    # Initializes a new instance of CacheCrispies::HashBuilder
+    #
+    # @param serializer [CacheCrispies::Base] an instance of a subclass of
+    #   CacheCrispies::Base
     def initialize(serializer)
       @serializer = serializer
       @condition_results = Memoizer.new
     end
 
+    # Builds the Hash
+    #
+    # @return [Hash]
     def call
       hash = {}
 
@@ -58,4 +68,4 @@ module CacheCrispies
       attribute.value_for(target, serializer.options)
     end
   end
-end
+end

data/lib/cache_crispies/memoizer.rb

@@ -1,9 +1,19 @@
+# frozen_string_literal: true
+
 module CacheCrispies
+  # Simple class to handle memoizing values by a key. This really just provides
+  # a bit of wrapper around doing this yourself with a hash.
   class Memoizer
     def initialize
       @cache = {}
     end
 
+    # Fetches a cached value for the given key, if it exists. Otherwise it calls
+    # the block and caches that value
+    #
+    # @param key [Object] the value to use as a cache key
+    # @yield the value to cache and return if there is a cache miss
+    # @return [Object] either the cached value or the block's value
     def fetch(key, &_block)
       # Avoid ||= because we need to memoize falsey values.
       return cache[key] if cache.key?(key)
@@ -15,4 +25,4 @@ module CacheCrispies
 
     attr_reader :cache
   end
-end
+end

data/lib/cache_crispies/plan.rb

@@ -1,7 +1,17 @@
+# frozen_string_literal: true
+
 module CacheCrispies
+  # Represents a plan on how to cache a given cacheable with a given serializer
   class Plan
     attr_reader :serializer, :cacheable, :options
 
+    # Initializes a new instance of CacheCrispies::Plan
+    #
+    # @param serializer [CacheCrispies::Base] a class inheriting from
+    #   CacheCrispies::Base
+    # @param cacheable [Object] typically ActiveRecord::Base or an enumerable
+    #   containing instances of ActiveRecord::Base, but could be anything
+    # @param options [Hash] any optional values from the serializer instance
     def initialize(serializer, cacheable, options = {})
       @serializer = serializer
       @cacheable = cacheable
@@ -9,14 +19,30 @@ module CacheCrispies
       @options = options
     end
 
+    # Whether or not the cacheable should be treated like a collection
+    #
+    # @return [Boolean] true if cacheable is a collection
     def collection?
       cacheable.respond_to?(:each)
     end
 
+    # Returns the cache_key in a format suitable for an ETag header
+    #
+    # @return [String] an MD5 digest of cache_key
     def etag
       Digest::MD5.hexdigest(cache_key)
     end
 
+    # Returns a string of cache keys for all dependent objects. Changes to any
+    # of keys should bust the overall key for this plan. The key consists of:
+    # - a global key for this gem
+    # - the serializers class name
+    # - a digest of the contents of the of serializer class file
+    # - any addon keys the serializer may define
+    # - the #cache_key method on the cacheable (ActiveRecord provides this by
+    #   default)
+    #
+    # @return [String] a suitable cache key
     def cache_key
       @cache_key ||=
         [
@@ -27,6 +53,11 @@ module CacheCrispies
         ].flatten.compact.join(CACHE_KEY_SEPARATOR)
     end
 
+    # Caches the contents of the block, if the plan is cacheable, otherwise
+    # calls yields to the block directly
+    #
+    # @yield calls the block that should return a value to be cached
+    # @return whatever the provided block returns
     def cache
       if cache?
         Rails.cache.fetch(cache_key) { yield }
@@ -35,6 +66,13 @@ module CacheCrispies
       end
     end
 
+    # Wraps a value in a JSON key/object. Returns json_hash directly if there
+    # is no key.
+    #
+    # @param json_hash [Hash, Array, Object] typically a JSON-ready Hash or
+    #   Array, but could be anything really
+    # @return [Hash, Object] will return a hash with a single key of #key,
+    #   unless there is no #key, then returns the json_hash directly.
     def wrap(json_hash)
       return json_hash unless key?
 
@@ -65,4 +103,4 @@ module CacheCrispies
       Digest::MD5.hexdigest(addons.join('|'))
     end
   end
-end
+end

data/lib/cache_crispies/version.rb

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+
 module CacheCrispies
-  VERSION = '0.1.0'.freeze
-end
+  # The version of the gem
+  VERSION = '0.1.1'
+end

data/spec/attribute_spec.rb

@@ -151,9 +151,9 @@ describe CacheCrispies::Attribute do
         let(:to) { OpenStruct }
 
         it 'raises an exception' do
-          expect { subject }.to raise_exception CacheCrispies::Attribute::InvalidCoersionType
+          expect { subject }.to raise_exception CacheCrispies::Attribute::InvalidCoercionType
         end
       end
     end
   end
-end
+end

data/spec/collection_spec.rb

@@ -20,9 +20,7 @@ describe CacheCrispies::Collection do
   let(:uncacheable_models) { [model1, model2] }
   let(:cacheable_models) {
     [model1, model2].tap do |models|
-      def models.cache_key
-        'cereals-key'
-      end
+      def models.cache_key() end
     end
   }
   let(:collection) { cacheable_models }

data/spec/memoizer_spec.rb

@@ -3,8 +3,6 @@ require 'spec_helper'
 describe CacheCrispies::Memoizer do
   describe '#fetch' do
     it 'only calls the block once per key' do
-      block = -> {}
-
       expect { |block| subject.fetch 1, &block }.to yield_with_no_args
       expect { |block| subject.fetch 1, &block }.to_not yield_with_no_args
       expect { |block| subject.fetch 2, &block }.to yield_with_no_args

data/spec/plan_spec.rb

@@ -49,7 +49,10 @@ describe CacheCrispies::Plan do
   end
 
   describe '#etag' do
-
+    it 'generates an MD5 digest of the cache_key' do
+      expect(subject).to receive(:cache_key).and_return 'foo'
+      expect(subject.etag).to eq Digest::MD5::hexdigest('foo')
+    end
   end
 
   describe '#cache_key' do
@@ -104,6 +107,21 @@ describe CacheCrispies::Plan do
   end
 
   describe '#cache' do
+    context 'when the plan is not cacheable' do
+      it "doesn't cache the results" do
+        expect(Rails).to_not receive(:cache)
+        subject.cache {}
+      end
+    end
+
+    context 'when the plan is not cacheable' do
+      it "doesn't cache the results" do
+        expect(subject).to receive(:cache?).and_return true
+        expect(subject).to receive(:cache_key).and_return 'bar'
+        expect(Rails).to receive_message_chain(:cache, :fetch).with('bar')
+        subject.cache {}
+      end
+    end
   end
 
   describe '#wrap' do

data/spec/spec_helper.rb

@@ -1,102 +1,21 @@
-require 'byebug'
+require 'simplecov'
+SimpleCov.start
 
+require 'byebug'
 require_relative '../lib/cache_crispies'
 
-# This file was generated by the `rspec --init` command. Conventionally, all
-# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
-# The generated `.rspec` file contains `--require spec_helper` which will cause
-# this file to always be loaded, without a need to explicitly require it in any
-# files.
-#
-# Given that it is always loaded, you are encouraged to keep this file as
-# light-weight as possible. Requiring heavyweight dependencies from this file
-# will add to the boot time of your test suite on EVERY test run, even for an
-# individual file that may not need all of that loaded. Instead, consider making
-# a separate helper file that requires the additional dependencies and performs
-# the additional setup, and require it from the spec files that actually need
-# it.
-#
-# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
 RSpec.configure do |config|
-  # rspec-expectations config goes here. You can use an alternate
-  # assertion/expectation library such as wrong or the stdlib/minitest
-  # assertions if you prefer.
   config.expect_with :rspec do |expectations|
-    # This option will default to `true` in RSpec 4. It makes the `description`
-    # and `failure_message` of custom matchers include text for helper methods
-    # defined using `chain`, e.g.:
-    #     be_bigger_than(2).and_smaller_than(4).description
-    #     # => "be bigger than 2 and smaller than 4"
-    # ...rather than:
-    #     # => "be bigger than 2"
     expectations.include_chain_clauses_in_custom_matcher_descriptions = true
   end
 
-  # rspec-mocks config goes here. You can use an alternate test double
-  # library (such as bogus or mocha) by changing the `mock_with` option here.
   config.mock_with :rspec do |mocks|
-    # Prevents you from mocking or stubbing a method that does not exist on
-    # a real object. This is generally recommended, and will default to
-    # `true` in RSpec 4.
     mocks.verify_partial_doubles = true
   end
 
-  # This option will default to `:apply_to_host_groups` in RSpec 4 (and will
-  # have no way to turn it off -- the option exists only for backwards
-  # compatibility in RSpec 3). It causes shared context metadata to be
-  # inherited by the metadata hash of host groups and examples, rather than
-  # triggering implicit auto-inclusion in groups with matching metadata.
   config.shared_context_metadata_behavior = :apply_to_host_groups
 
-  # The settings below are suggested to provide a good initial experience
-  # with RSpec, but feel free to customize to your heart's content.
-  #   # This allows you to limit a spec run to individual examples or groups
-  #   # you care about by tagging them with `:focus` metadata. When nothing
-  #   # is tagged with `:focus`, all examples get run. RSpec also provides
-  #   # aliases for `it`, `describe`, and `context` that include `:focus`
-  #   # metadata: `fit`, `fdescribe` and `fcontext`, respectively.
-  #   config.filter_run_when_matching :focus
-  #
-  #   # Allows RSpec to persist some state between runs in order to support
-  #   # the `--only-failures` and `--next-failure` CLI options. We recommend
-  #   # you configure your source control system to ignore this file.
-  #   config.example_status_persistence_file_path = "spec/examples.txt"
-  #
-  #   # Limits the available syntax to the non-monkey patched syntax that is
-  #   # recommended. For more details, see:
-  #   #   - http://rspec.info/blog/2012/06/rspecs-new-expectation-syntax/
-  #   #   - http://www.teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
-  #   #   - http://rspec.info/blog/2014/05/notable-changes-in-rspec-3/#zero-monkey-patching-mode
-  #   config.disable_monkey_patching!
-  #
-  #   # This setting enables warnings. It's recommended, but in some cases may
-  #   # be too noisy due to issues in dependencies.
-  #   config.warnings = true
-  #
-  #   # Many RSpec users commonly either run the entire suite or an individual
-  #   # file, and it's useful to allow more verbose output when running an
-  #   # individual spec file.
-  #   if config.files_to_run.one?
-  #     # Use the documentation formatter for detailed output,
-  #     # unless a formatter has already been configured
-  #     # (e.g. via a command-line flag).
-  #     config.default_formatter = "doc"
-  #   end
-  #
-  #   # Print the 10 slowest examples and example groups at the
-  #   # end of the spec run, to help surface which specs are running
-  #   # particularly slow.
-  #   config.profile_examples = 10
-  #
-  #   # Run specs in random order to surface order dependencies. If you find an
-  #   # order dependency and want to debug it, you can fix the order by providing
-  #   # the seed, which is printed after each run.
-  #   #     --seed 1234
-  #   config.order = :random
-  #
-  #   # Seed global randomization in this process using the `--seed` CLI option.
-  #   # Setting this allows you to use `--seed` to deterministically reproduce
-  #   # test failures related to randomization by passing the same `--seed` value
-  #   # as the one that triggered the failure.
-  #   Kernel.srand config.seed
+  config.warnings = true
+  config.order = :random
+  Kernel.srand config.seed
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cache_crispies
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Adam Crownoble
@@ -80,6 +80,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 3.8.0
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.17'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.17'
 description: 
 email: adam@codenoble.com
 executables: []