adornable 1.0.3 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 39c5f35488e69b6f4de57d24b3a4867552fdb7e72a59a98017cd59af19dbc7f7
-  data.tar.gz: 3d9998525bb6393c681cb2688d3ba3d2df321ae5e39f598e9c8ea7a3bed9cd8e
+  metadata.gz: ece582a2ce4c7093792eacfa04863a2c71a8a5bee12fceb0f964356b58f997c5
+  data.tar.gz: dabd571e4161e633d40d15bdaccee37bf8646ec7f7cdd2d4773feaeb207c5e9d
 SHA512:
-  metadata.gz: 9a26ac80096736eaa6e20d6c63250686491b528e915603723f933879dfda9d10ce0e17e73531e7a4c46b7eb4d47efdbb152f9c0da78fab89850740a11fb6f8d2
-  data.tar.gz: 44ea1ed9f80932ea5214e7287bbbc40c5a385c10eb5b9dce52f34dc5e915fff6ff3d5da854084f0a342d6728657420f4ce940d1e27d94c3c3cb629bddbd9f272
+  metadata.gz: b0dbae5d19cd42fe225b054bb9245ff9946c417d75c1decdb23441be527991a6186a90abaa0ce46faa5ad61cc3dfbfa01d5d0fc063620dbc4bb69db94a44a9f7
+  data.tar.gz: 58416d66482d8b39ea8ee9b3ac532c6e37b6a2de811542551fe4a857927beb5117bc13ef3a460320f19eaca683bf97939a0e257548fc12a1c81aec39a6c78163

data/.rubocop.yml

@@ -3,45 +3,73 @@ require:
   - rubocop-rspec
   - rubocop-rake
 
+# Globals
+
+AllCops:
+  NewCops: enable
+
 # Layout
 
 Layout/LineLength:
   Max: 120
   Exclude:
     - 'spec/**/*_spec.rb'
-    - 'test/**/*_spec.rb'
 
 Layout/EndAlignment:
   EnforcedStyleAlignWith: variable
 
+Layout/FirstArrayElementIndentation:
+  EnforcedStyle: consistent
+
 # Metrics
 
 Metrics/AbcSize:
   CountRepeatedAttributes: false
   Exclude:
     - 'spec/**/*_spec.rb'
-    - 'test/**/*_spec.rb'
 
 Metrics/BlockLength:
   Exclude:
     - 'spec/**/*_spec.rb'
-    - 'test/**/*_spec.rb'
 
 Metrics/ClassLength:
+  Max: 150
+  CountComments: false
+  CountAsOne:
+    - array
+    - hash
+    - heredoc
+  Exclude:
+    - 'spec/**/*_spec.rb'
+
+Metrics/MethodLength:
+  Max: 20
+  CountComments: false
+  CountAsOne:
+    - array
+    - hash
+    - heredoc
+
+Metrics/ModuleLength:
+  Max: 150
+  CountComments: false
+  CountAsOne:
+    - array
+    - hash
+    - heredoc
   Exclude:
     - 'spec/**/*_spec.rb'
-    - 'test/**/*_spec.rb'
 
 # Rspec
 
 RSpec/ExampleLength:
-  Max: 20
+  Max: 25
 
 RSpec/MessageSpies:
   Enabled: false
 
 RSpec/MultipleExpectations:
-  Max: 5
+  Enabled: false
 
 RSpec/NestedGroups:
   Max: 10
@@ -57,3 +85,12 @@ Style/ExpandPathArguments:
 
 Style/StringLiterals:
   Enabled: false
+
+Style/TrailingCommaInArguments:
+  EnforcedStyleForMultiline: consistent_comma
+
+Style/TrailingCommaInArrayLiteral:
+  EnforcedStyleForMultiline: consistent_comma
+
+Style/TrailingCommaInHashLiteral:
+  EnforcedStyleForMultiline: consistent_comma

data/README.md

@@ -90,7 +90,7 @@ class RandomValueGenerator
   end
 
   decorate :log
-  decorate :memoize_for_arguments
+  decorate :memoize
   def values(max)
     (1..max).map { rand }
   end
@@ -149,35 +149,37 @@ class Foo
 
   decorate :log
   def some_method
-    # ...
+    # the method name (Foo#some_method) and arguments will be logged
   end
 
   decorate :memoize
   def some_other_method
-    # ...
+    # the return value will be cached
   end
 
-  decorate :memoize_for_arguments
+  decorate :memoize
   def yet_another_method(some_arg, some_other_arg = true, key_word_arg:, key_word_arg_with_default: 123)
-    # ...
+    # the return value will be cached based on the arguments the method receives
   end
 
   decorate :log
-  decorate :memoize_for_arguments
+  decorate :memoize, for_any_arguments: true
   def oh_boy_another_method(some_arg, some_other_arg = true, key_word_arg:, key_word_arg_with_default: 123)
-    # ...
+    # the method name (Foo#oh_boy_another_method) and arguments will be logged
+    # the return value will be cached regardless of the arguments received
   end
 
   decorate :log
   def self.yeah_it_works_on_class_methods_too
-    # ...
+    # the method name (Foo::yeah_it_works_on_class_methods_too) and arguments
+    # will be logged
   end
 end
 ```
 
 - `decorate :log` logs the method name and any passed arguments to the console
-- `decorate :memoize` caches the result of the first call and returns that initial result (and does not execute the method again) for any additional calls
-- `decorate :memoize_for_arguments` acts like `decorate :memoize` but it namespaces that cache by the arguments passed, so it will re-compute (and cache the result) only if the arguments change... if the arguments are the same as any previous time the method was called, it will return the cached result instead
+- `decorate :memoize` caches the result of the first call and returns that initial result (and does not execute the method again) for any additional calls. By default, it namespaces the cache by the arguments passed to the method, so it will re-compute  only if the arguments change; if the arguments are the same as any previous time the method was called, it will return the cached result instead.
+  - pass the `for_any_arguments: true` option (e.g., `decorate :memoize, for_any_arguments: true`) to ignore the arguments in the caching process and simply memoize the result no matter what
 
 > **Note:** in the case of multiple decorators decorating a method, each is executed from top to bottom.
 
@@ -188,17 +190,18 @@ You can reference any decorator method you write, like so:
 ```rb
 class FooDecorators
   # Note: this is a class method
-  def self.blast_it(method_receiver, method_name, arguments)
+  def self.blast_it(context)
     puts "Blasting it!"
     value = yield
     "#{value}!"
   end
 
   # Note: this is an instance method
-  def wait_for_it(method_receiver, method_name, arguments)
-    puts "Waiting..."
+  def self.wait_for_it(context, dot_count: 3)
+    ellipsis = dot_count.times.map { '.' }.join
+    puts "Waiting for it#{ellipsis}"
     value = yield
-    "#{value}..."
+    "#{value}#{ellipsis}"
   end
 end
 
@@ -240,49 +243,57 @@ foo.yet_another_method(123, bloop: "bleep")
 
 Use the `from:` option to specify what should receive the decorator method. Keep in mind that the decorator method will be called on the thing specified by `from:`... so, if you provide a class, it better be a class method, and if you supply an instance, it better be an instance method.
 
-Every decorator method must take the following arguments:
+Every custom decorator method that you define must take one required argument (`context`) and any number of keyword arguments.
 
-- `method_receiver`: the actual object that the [decorated] method is being called on (an object/class); e.g., `Foo` or an instance of `Foo`
-- `method_name`: the name of the [decorated] method being called on `method_receiver` (a symbol); e.g., `:some_method` or `:other_method`
-- `arguments`: an array of arguments passed to the [decorated] method, including keyword arguments; e.g., if `:yet_another_method` was called like `Foo.new.yet_another_method(123, bar: true)` then `arguments` would be `[123, {:bar=>true}]`
+The **required argument** is an instance of `Adornable::Context`, which has some useful information about the decorated method being called
 
-> **Note:** Every decorator method _should_ also probably `yield` at some point in the method body. I say _"should"_ because, technically, you don't have to, but if you don't then the original method will never be called. That's a valid use-case, but 99% of the time you're gonna want to `yield`.
->
-> **Note:** the return value of your decorator **will replace the return value of the decorated method,** so _also_ you should probably return whatever value `yield` returned. Again, it is a valid use case to return something _else,_ but 99% of the time you probably want to return the value returned by the wrapped method.
+- `Adornable::Context#method_receiver`: the actual object that the [decorated] method is being called on (an object/class; e.g., `Foo` or an instance of `Foo`)
+- `Adornable::Context#method_name`: the name of the [decorated] method being called on `method_receiver` (a symbol; e.g., `:some_method` or `:other_method`)
+- `Adornable::Context#method_arguments`: an array of arguments passed to the [decorated] method, including keyword arguments as a final hash (e.g., if `:yet_another_method` was called like `Foo.new.yet_another_method(123, bar: true)` then `arguments` would be `[123, {:bar=>true}]`)
 
-Contrived example of when you might want to muck around with the return value:
+The **optional keyword arguments** are any parameters you want to be able to pass to the decorator method when decorating a method with `::decorate`:
 
-```rb
-class FooDecorators
-  def self.coerce_to_int(method_receiver, method_name, arguments)
-    value = yield
-    new_value = value.strip.to_i
-    puts "New value: #{value.inspect} (class: #{value.class})"
-    new_value
-  end
-end
-
-class Foo
-  extend Adornable
-
-  decorate :coerce_to_int, from: FooDecorators
-  def get_number_from_user
-    print "Enter a number: "
-    value = gets
-    puts "Value: #{value.inspect} (class: #{value.class})"
-    value
-  end
-end
+- If you define a decorator like `def self.some_decorator(context)` then it takes no options when it is used: `decorate :some_decorator`
+- If you define a decorator like `def self.some_decorator(context, some_option:)` then it takes one _required_ keyword argument when it is used: `decorate :some_decorator, some_option: 123` (`::some_decorator`, will receive `123` every time the method it's decorating is called)
+- Similarly, if you define a decorator like `def self.some_decorator(context, some_option: 456)`, then it takes one _optional_ keyword argument when it is used: `decorate :some_decorator` is valid (and implies `some_option: 456` since it has a default), and `decorate :some_decorator, some_option: 789` is valid as well
 
-foo = Foo.new
+> **Note:** Every decorator method should _probably_ `yield` at some point in the method body. I say _"should"_ because, technically, you don't have to, but if you don't then the original method will never be called. That's a valid use-case, but 99% of the time you're gonna want to `yield`.
 
-foo.get_number_from_user
-# Enter a number
-# > 123
-# Value: "123" (class: String)
-# New value: 123 (class: Integer)
-#=> 123
-```
+> **Note:** the return value of your decorator **will replace the return value of the decorated method,** so _also_ you should probably return whatever value `yield` returned. Again, it is a valid use case to return something _else,_ but 99% of the time you probably want to return the value returned by the wrapped method.
+>
+> A contrived example of when you might want to muck around with the return value:
+>
+> ```rb
+> class FooDecorators
+>   def self.coerce_to_int(context)
+>     value = yield
+>     new_value = value.strip.to_i
+>     puts "New value: #{value.inspect} (class: #{value.class})"
+>     new_value
+>   end
+> end
+>
+> class Foo
+>   extend Adornable
+>
+>   decorate :coerce_to_int, from: FooDecorators
+>   def get_number_from_user
+>     print "Enter a number: "
+>     value = gets
+>     puts "Value: #{value.inspect} (class: #{value.class})"
+>     value
+>   end
+> end
+>
+> foo = Foo.new
+>
+> foo.get_number_from_user
+> # Enter a number
+> # > 123
+> # Value: "123" (class: String)
+> # New value: 123 (class: Integer)
+> #=> 123
+> ```
 
 #### Using custom decorators implicitly
 
@@ -291,7 +302,7 @@ You can also register decorator receivers so that you don't have to reference th
 ```rb
 class FooDecorators
   # Note: this is a class method
-  def self.blast_it(method_receiver, method_name, arguments)
+  def self.blast_it(context)
     puts "Blasting it!"
     value = yield
     "#{value}!"
@@ -300,10 +311,11 @@ end
 
 class MoreFooDecorators
   # Note: this is a class method
-  def self.wait_for_it(method_receiver, method_name, arguments)
-    puts "Waiting for it..."
+  def self.wait_for_it(context, dot_count: 3)
+    ellipsis = dot_count.times.map { '.' }.join
+    puts "Waiting for it#{ellipsis}"
     value = yield
-    "#{value}..."
+    "#{value}#{ellipsis}"
   end
 end
 
@@ -314,7 +326,7 @@ class Foo
   add_decorators_from MoreFooDecorators
 
   decorate :blast_it
-  decorate :wait_for_it
+  decorate :wait_for_it, dot_count: 9
   def some_method
     "haha I'm a method"
   end
@@ -324,12 +336,12 @@ foo = Foo.new
 
 foo.some_method
 # Blasting it!
-# Waiting for it...
-#=> "haha I'm a method!..."
+# Waiting for it.........
+#=> "haha I'm a method!........."
 ```
 
-> **Note:** In the case of duplicate decorator methods, later receivers registered with `::add_decorators_from` will override any duplicate decorators from earlier registered receivers.
->
+> **Note:** In the case of duplicate decorator methods, later receivers registered with `::add_decorators_from` will override any decorators by the same name from earlier registered receivers.
+
 > **Note:** in the case of multiple decorators decorating a method, each is executed from top to bottom; i.e., the top wraps the next, which wraps the next, and so on, until the method itself is wrapped.
 
 ## Development
@@ -340,12 +352,18 @@ foo.some_method
 bin/setup
 ```
 
-### Run testss
+### Run the tests
 
 ```bash
 rake spec
 ```
 
+### Run the linter
+
+```bash
+rubocop
+```
+
 ### Create release
 
 ```

data/adornable.gemspec

@@ -25,11 +25,12 @@ Gem::Specification.new do |spec|
   spec.executables = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  spec.add_development_dependency "bundler", "~> 1.17"
-  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "bundler", "~> 2.2"
+  spec.add_development_dependency "rake", "~> 13.0"
   spec.add_development_dependency "rspec", "~> 3.0"
   spec.add_development_dependency "rubocop", "~> 1.10"
   spec.add_development_dependency "rubocop-performance", "~> 1.9"
   spec.add_development_dependency "rubocop-rake", "~> 0.5"
   spec.add_development_dependency "rubocop-rspec", "~> 2.2"
+  spec.add_development_dependency "solargraph"
 end

data/lib/adornable.rb

@@ -13,7 +13,7 @@ module Adornable
     @adornable_machinery ||= Adornable::Machinery.new
   end
 
-  def decorate(decorator_name, from: nil, defer_validation: false)
+  def decorate(decorator_name, from: nil, defer_validation: false, **decorator_options)
     if Adornable::Utils.blank?(name)
       raise Adornable::Error::InvalidDecoratorArguments, "Decorator name must be provided."
     end
@@ -21,7 +21,8 @@ module Adornable
     adornable_machinery.accumulate_decorator!(
       name: decorator_name,
       receiver: from,
-      defer_validation: !!defer_validation
+      defer_validation: !!defer_validation,
+      decorator_options: decorator_options,
     )
   end
 

data/lib/adornable/context.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Adornable
+  # A context object is passed to the decorator method, and contains information
+  # about the decorated method being called.
+  class Context
+    attr_reader(*%i[
+      method_receiver
+      method_name
+      method_arguments
+      decorator_name
+      decorator_options
+    ])
+
+    def initialize(method_receiver:, method_name:, method_arguments:, decorator_name:, decorator_options:)
+      @method_receiver = method_receiver
+      @method_name = method_name
+      @method_arguments = method_arguments
+      @decorator_name = decorator_name
+      @decorator_options = decorator_options
+    end
+  end
+end

data/lib/adornable/decorators.rb

@@ -1,35 +1,42 @@
 # frozen_string_literal: true
 
+require 'adornable/utils'
+
 module Adornable
   # `Adornable::Decorators` is used as the default namespace for decorator
   # methods when a decorator method that is neither explicitly sourced (via the
   # `decorate from: <receiver>` option) nor implicitly sourced (via the
   # `add_decorators_from <receiver>` macro).
   class Decorators
-    def self.log(method_receiver, method_name, arguments)
-      receiver_name, name_delimiter = if method_receiver.is_a?(Class)
-        [method_receiver.to_s, '::']
-      else
-        [method_receiver.class.to_s, '#']
-      end
-      full_name = "`#{receiver_name}#{name_delimiter}#{method_name}`"
-      arguments_desc = arguments.empty? ? "no arguments" : "arguments `#{arguments.inspect}`"
+    def self.log(context)
+      method_receiver = context.method_receiver
+      method_name = context.method_name
+      method_args = context.method_arguments
+      full_name = Adornable::Utils.formal_method_name(method_receiver, method_name)
+      arguments_desc = method_args.empty? ? "no arguments" : "arguments `#{method_args.inspect}`"
       puts "Calling method #{full_name} with #{arguments_desc}"
       yield
     end
 
-    def self.memoize(method_receiver, method_name, _arguments)
+    def self.memoize(context, for_any_arguments: false, &block)
+      return memoize_for_arguments(context, &block) unless for_any_arguments
+
+      method_receiver = context.method_receiver
+      method_name = context.method_name
       memo_var_name = :"@adornable_memoized_#{method_receiver.object_id}_#{method_name}"
       existing = instance_variable_get(memo_var_name)
       value = existing.nil? ? yield : existing
       instance_variable_set(memo_var_name, value)
     end
 
-    def self.memoize_for_arguments(method_receiver, method_name, arguments)
+    def self.memoize_for_arguments(context)
+      method_receiver = context.method_receiver
+      method_name = context.method_name
+      method_args = context.method_arguments
       memo_var_name = :"@adornable_memoized_for_arguments_#{method_receiver.object_id}_#{method_name}"
       memo = instance_variable_get(memo_var_name) || {}
       instance_variable_set(memo_var_name, memo)
-      args_key = arguments.inspect
+      args_key = method_args.inspect
       memo[args_key] = yield if memo[args_key].nil?
       memo[args_key]
     end

data/lib/adornable/machinery.rb

@@ -2,6 +2,7 @@
 
 require 'adornable/utils'
 require 'adornable/error'
+require 'adornable/context'
 
 module Adornable
   class Machinery # :nodoc:
@@ -9,12 +10,17 @@ module Adornable
       registered_decorator_receivers.unshift(receiver)
     end
 
-    def accumulate_decorator!(name:, receiver:, defer_validation:)
+    def accumulate_decorator!(name:, receiver:, defer_validation:, decorator_options:)
       name = name.to_sym
       receiver ||= find_suitable_receiver_for(name)
       validate_decorator!(name, receiver) unless defer_validation
 
-      decorator = { name: name, receiver: receiver }
+      decorator = {
+        name: name,
+        receiver: receiver,
+        options: decorator_options || {},
+      }
+
       accumulated_decorators << decorator
     end
 
@@ -82,15 +88,31 @@ module Adornable
       @class_method_decorators[name] = decorators || []
     end
 
-    def run_decorators(decorators, bound_method, *args)
-      return bound_method.call(*args) if Adornable::Utils.blank?(decorators)
+    def run_decorators(decorators, bound_method, *method_arguments)
+      return bound_method.call(*method_arguments) if Adornable::Utils.blank?(decorators)
 
       decorator, *remaining_decorators = decorators
-      name = decorator[:name]
-      receiver = decorator[:receiver]
-      validate_decorator!(name, receiver, bound_method)
-      receiver.send(name, bound_method.receiver, bound_method.name, args) do
-        run_decorators(remaining_decorators, bound_method, *args)
+      decorator_name = decorator[:name]
+      decorator_receiver = decorator[:receiver]
+      decorator_options = decorator[:options]
+      validate_decorator!(decorator_name, decorator_receiver, bound_method)
+
+      context = Adornable::Context.new(
+        method_receiver: bound_method.receiver,
+        method_name: bound_method.name,
+        method_arguments: method_arguments,
+        decorator_name: decorator_name,
+        decorator_options: decorator_options,
+      )
+
+      send_parameters = if Adornable::Utils.present?(decorator_options)
+        [decorator_name, context, decorator_options]
+      else
+        [decorator_name, context]
+      end
+
+      decorator_receiver.send(*send_parameters) do
+        run_decorators(remaining_decorators, bound_method, *method_arguments)
       end
     end
 
@@ -100,15 +122,13 @@ module Adornable
       end
     end
 
-    # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity, Layout/LineLength
+    # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity, Layout/LineLength
     def validate_decorator!(decorator_name, decorator_receiver, bound_method = nil)
       return if decorator_receiver.respond_to?(decorator_name)
 
       location_hint = if bound_method
         method_receiver = bound_method.receiver
-
         method_full_name = method_receiver.is_a?(Class) ? "#{method_receiver}::#{method.name}" : "#{method_receiver.class}##{method.name}"
-
         method_location = bound_method.source_location
         "Cannot decorate `#{method_full_name}` (defined at `#{method_location.first}:#{method_location.second})."
       end
@@ -126,6 +146,6 @@ module Adornable
       message = [location_hint, base_message, definition_hint].compact.join(" ")
       raise Adornable::Error::InvalidDecoratorArguments, message
     end
-    # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity, Layout/LineLength
+    # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity, Layout/LineLength
   end
 end

data/lib/adornable/utils.rb

@@ -14,6 +14,15 @@ module Adornable
       def presence(value)
         value if present?(value)
       end
+
+      def formal_method_name(method_receiver, method_name)
+        receiver_name, name_delimiter = if method_receiver.is_a?(Class)
+          [method_receiver.to_s, '::']
+        else
+          [method_receiver.class.to_s, '#']
+        end
+        "`#{receiver_name}#{name_delimiter}#{method_name}`"
+      end
     end
   end
 end

data/lib/adornable/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Adornable
-  VERSION = "1.0.3"
+  VERSION = "1.1.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: adornable
 version: !ruby/object:Gem::Version
-  version: 1.0.3
+  version: 1.1.0
 platform: ruby
 authors:
 - Keegan Leitz
-autorequire:
+autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-02-15 00:00:00.000000000 Z
+date: 2021-02-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -16,28 +16,28 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.17'
+        version: '2.2'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.17'
+        version: '2.2'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '13.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '13.0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -108,6 +108,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2.2'
+- !ruby/object:Gem::Dependency
+  name: solargraph
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Method decorators for Ruby
 email:
 - kjleitz@gmail.com
@@ -120,7 +134,6 @@ files:
 - ".rubocop.yml"
 - ".travis.yml"
 - Gemfile
-- Gemfile.lock
 - LICENSE
 - README.md
 - Rakefile
@@ -128,6 +141,7 @@ files:
 - bin/console
 - bin/setup
 - lib/adornable.rb
+- lib/adornable/context.rb
 - lib/adornable/decorators.rb
 - lib/adornable/error.rb
 - lib/adornable/machinery.rb
@@ -137,7 +151,7 @@ homepage: https://github.com/kjleitz/adornable
 licenses:
 - MIT
 metadata: {}
-post_install_message:
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -152,8 +166,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.8
-signing_key:
+rubygems_version: 3.1.4
+signing_key: 
 specification_version: 4
 summary: Method decorators for Ruby
 test_files: []