Merge pull request #1 from splitwise/jess/update-readme

Update readme and rubocop

Author: agrberg

.gitignore

@@ -11,3 +11,6 @@
 
 #RSpec
 spec/examples.txt
+
+#Rubymine
+.idea

README.md

@@ -5,10 +5,10 @@ By [Splitwise](https://www.splitwise.com)
 Cacheable is a gem which intends to add method caching in an [aspect-oriented programming (AOP)](https://en.wikipedia.org/wiki/Aspect-oriented_programming) fashion in Ruby. Its core goals are:
 
 * ease of use (method annotation)
-* flexibility (simple adaptablability for any cache backend)
+* flexibility (simple adaptability for any cache backend)
 * portability (plain Ruby for use with any framework)
 
-While Rails is not a requirement, Cacheable was built inside a mature Rails app and later extracted. This first release will seemlyless work in Rails and only includes an adapter for an in-memory cache backed by a simple Hash. This may be enough for you needs but it is more likely that additional cache adapters will need to be written.
+While Rails is not a requirement, Cacheable was built inside a mature Rails app and later extracted. This first release will seamlessly work in Rails and only includes an adapter for an in-memory cache backed by a simple Hash. This may be enough for your needs but it is more likely that additional cache adapters will need to be written.
 
 See more about [Cache Adapters](cache-adapters.md).
 
@@ -32,7 +32,7 @@ Cacheable.cache_adapter = :memory
 
 ### Simple Implementation Example
 
-Cacheable is designed to work seemlessly with your already existings codebase. Consider the following contrived class:
+Cacheable is designed to work seamlessly with your already existing codebase. Consider the following contrived class:
 
 ```ruby
 class SimpleExample
@@ -62,7 +62,7 @@ class SimpleExample
 end
 ```
 
-**Thats it!** There's some complex Ruby magic going on under the hood but to the end user you can simply call `expensive_calculation` and the result will be retreived from the cache, if available, or generated and placed into the cache. To confirm it is working, fire up an IRB console try the following:
+**That's it!** There's some complex Ruby magic going on under the hood but to the end user you can simply call `expensive_calculation` and the result will be retrieved from the cache, if available, or generated and placed into the cache. To confirm it is working, fire up an IRB console try the following:
 
 ```irb
 > s = SimpleExample.new
@@ -81,7 +81,7 @@ Cacheable also adds two useful methods to your class.
 
 #### Skip the Cache via `#{method}_without_cache`
 
-The cache can intentionally be skipped by appending `_without_cache` to the method name. This invocation with neither check the cache nor populate it as if you called the original method and never used Cacheable.
+The cache can intentionally be skipped by appending `_without_cache` to the method name. This invocation will neither check the cache nor populate it.  It is as if you called the original method and never used Cacheable.
 
 ```irb
 > s = SimpleExample.new
@@ -95,7 +95,7 @@ beginning expensive method
 
 #### Remove the Value via `clear_#{method}_cache`
 
-The cache can be cleared at any time by calling `clear_#{your_method_name}_cache`.
+The cached value can be cleared at any time by calling `clear_#{your_method_name}_cache`.
 
 ```irb
 > s = SimpleExample.new
@@ -151,7 +151,7 @@ So if we called `CustomKeyExample.new.my_method(123)` we would get the cache key
 
 `"my_method called on #<CustomKeyExample:0x0…0> with Integer::123"`.
 
-### Conditional Cacheing
+### Conditional Caching
 
 You can control if a method should be cached by supplying a proc to the `unless:` option which will get the same arguments as `key_format:`. Alternatively this method can be defined on the class and a symbol of the name of the method can be passed. **Note**: When using a symbol, the first argument will not be passed but will be available in the method as `self`. The following example will not cache the value if the first argument to the method is `false`.
 
@@ -189,7 +189,7 @@ cacheable :these, :methods, :share, :options, key_format: key_proc, unless: unle
 cacheable :this_method_has_its_own_options, unless: unless_proc2
 ```
 
-### Class Method Cacheing
+### Class Method Caching
 
 You can cache class methods just as easily as a Ruby class is just an instance of `Class`. You simply need to `include Cacheable` within the `class << self` block. Methods can be defined in this block or outside using the `def self.` syntax.
 

cache-adapters.md

@@ -2,7 +2,7 @@
 
 A cache adapter is an object that Cacheable can use as an interface to your system's cache. Cacheable will work out of the box using the object returned by `Rails.cache` as a cache adapter.
 
-The other adapter provided with the library is the [Memory Adapter](lib/cacheable/cache_adapters/memory_adapter.rb). Is a simple memoizing cache used in testing. It is little more than an object that conforms to the protocol and is backed by a Ruby Hash. When writting a new cache adapter it can be used as a template.
+The other adapter provided with the library is the [Memory Adapter](lib/cacheable/cache_adapters/memory_adapter.rb). Is a simple memoizing cache used in testing. It is little more than an object that conforms to the protocol and is backed by a Ruby Hash. When writing a new cache adapter it can be used as a template.
 
 ### Protocol
 
@@ -16,7 +16,7 @@ There are only two methods the cache adapter protocol requires.
 
 #### `delete(key)`
 
-`delete` takes a key and removes it's associated value in the cache. While not currently dependend on by Cacheable, it appears the standard is to return `true` if the value was present and removed and `false` if not present to begin with.
+`delete` takes a key and removes it's associated value in the cache. While not currently depended on by Cacheable, it appears the standard is to return `true` if the value was present and removed and `false` if not present to begin with.
 
 #### Additional useful methods
 

cacheable.gemspec

@@ -1,19 +1,20 @@
-# -*- encoding: utf-8 -*-
 # frozen_string_literal: true
 
-$LOAD_PATH.push File.expand_path("../lib", __FILE__)
+$LOAD_PATH.push File.expand_path('lib', __dir__)
 require 'cacheable/version'
 
 Gem::Specification.new do |s|
   s.name        = 'cacheable'
   s.version     = Cacheable::VERSION
   s.date        = '2018-07-31'
   s.summary     = 'Add caching to any Ruby method in a aspect orientated programming approach.'
-  s.description = 'Add caching simply without modifying your existing code. Inlcudes configurable options for simple cache invalidation. See README on github for more information.'
+  s.description = 'Add caching simply without modifying your existing code. '\
+                  'Includes configurable options for simple cache invalidation. '\
+                  'See README on github for more information.'
   s.authors     = ['Jess Hottenstein', 'Ryan Laughlin', 'Aaron Rosenberg']
   s.email       = 'support@splitwise.com'
   s.files       = Dir['lib/**/*', 'README.md', 'cache-adapters.md']
   s.homepage    = 'https://github.com/splitwise/cacheable'
   s.licenses    = 'MIT'
-  s.required_ruby_version = '>= 2.0.0'
+  s.required_ruby_version = '>= 2.3.0'
 end

lib/cacheable/cache_adapter.rb

@@ -15,12 +15,12 @@ def cache_adapter
     end
 
     def cache_adapter=(name_or_adapter)
-      @_cache_adapter = interprete_adapter(name_or_adapter)
+      @_cache_adapter = interpret_adapter(name_or_adapter)
     end
 
     private
 
-    def interprete_adapter(name_or_adapter)
+    def interpret_adapter(name_or_adapter)
       return name_or_adapter if cache_adapter?(name_or_adapter)
 
       unless [Symbol, String].include?(name_or_adapter.class)

lib/cacheable/method_generator.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require 'English'
 
 module Cacheable

spec/cacheable/cache_adapter_spec.rb

@@ -1,5 +1,3 @@
-require 'spec_helper'
-
 RSpec.describe Cacheable::CacheAdapter do
   subject(:adapter_object) { Class.new { extend(Cacheable::CacheAdapter) } }
 

spec/cacheable/cache_adapters/memory_adapter_spec.rb

@@ -1,4 +1,3 @@
-require 'spec_helper'
 require 'cacheable/cache_adapters/memory_adapter'
 
 RSpec.describe Cacheable::CacheAdapters::MemoryAdapter do

spec/cacheable/cacheable_spec.rb

@@ -1,5 +1,3 @@
-require 'spec_helper'
-
 RSpec.describe Cacheable do
   subject(:cacheable_object) { cacheable_class.new }
 
@@ -231,8 +229,8 @@ class RealClassName
     end
   end
 
-  describe 'syntatic sugar' do
-    it 'allows cachable to be used before the method is defined' do
+  describe 'syntactic sugar' do
+    it 'allows cacheable to be used before the method is defined' do
       cacheable_called_before_definition = :cacheable_called_before_definition
       inner_method = cacheable_method_inner
       cacheable_class.class_eval do