snfoil-context 0.0.2 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 192d032e33ddaa32cb1ead86d97947a03eaee657af7c26a44effe1c47eeefe7a
-  data.tar.gz: e181f4ac51ccc95c0e50377b3186679b5f313824f4a650f7dbe80efb69e4f68b
+  metadata.gz: a9996ed485265b54e92858f7471b6ed2ccfc3970b6ab7bed338f0b3ab729d240
+  data.tar.gz: 2427755a9b61cf1fad8ddc48eaa6e5c1e7da651b6c6b8f760f6594e1a973c471
 SHA512:
-  metadata.gz: 41bbbdce248d49d94e646a2d446ff99ce9fa195dc235024cd85030d8f4664c2f0ddb4b1b42ba906df50ce71d330425bc5d582a8783be10603f9dc94745b10871
-  data.tar.gz: d0cbddc6b61b6bccae81d5a6b2db8930cada0f9f9729595aa1203252440f93b0d8e3fc9ea630dd2790eba7e69d17242390e76766d6e5b36dc35ef87fc4c3c5c5
+  metadata.gz: d8e89dc09f5d1a1ca531487b04e9392c5323330c232d9f3a72946c4130ead35425451a2bec1d7a522702c414cdd7cb08ea85447f60d89a72a948fda27f17d667
+  data.tar.gz: a1f773ecb81a5a4ee2ffce81b3bf350c49e18078ba465f35e4ed824b01587dd5a9d5fc4897131a1c4b93fe9675655c086d489c9d99e0c05615af139f4644d13f

data/.fasterer.yml

@@ -0,0 +1,22 @@
+speedups:
+  rescue_vs_respond_to: true
+  module_eval: true
+  shuffle_first_vs_sample: true
+  for_loop_vs_each: true
+  each_with_index_vs_while: false
+  map_flatten_vs_flat_map: true
+  reverse_each_vs_reverse_each: true
+  select_first_vs_detect: true
+  sort_vs_sort_by: true
+  fetch_with_argument_vs_block: true
+  keys_each_vs_each_key: true
+  hash_merge_bang_vs_hash_brackets: true
+  block_vs_symbol_to_proc: true
+  proc_call_vs_yield: true
+  gsub_vs_tr: true
+  select_last_vs_reverse_detect: true
+  getter_vs_attr_reader: true
+  setter_vs_attr_writer: true
+
+exclude_paths:
+  - 'vendor/**/*.rb'

data/.github/workflows/main.yml

@@ -1,5 +1,5 @@
 name: build
-on: 
+on:
   push:
     branches: [ main ]
   pull_request:
@@ -11,7 +11,7 @@ jobs:
 
     strategy:
       matrix:
-        ruby-version: [2.7, 2.6, 2.5]
+        ruby-version: [2.7, 2.6, 2.5, '3.0']
 
     steps:
       - uses: actions/checkout@v2
@@ -43,4 +43,7 @@ jobs:
         run: bundle install
       - name: Run rubocop
         run: bundle exec rubocop
-
+      - name: Run fasterer
+        run: bundle exec fasterer
+      - name: Run bundle audit
+        run: bundle exec bundle audit check --update

data/.rubocop.yml

@@ -24,6 +24,7 @@ Lint/EmptyClass:
 Metrics/BlockLength:
   Exclude:
     - spec/**/*_spec.rb
+    - snfoil-context.gemspec
 
 # ================ RSPEC ================
 RSpec/FilePath:

data/README.md

@@ -2,7 +2,7 @@
 
 ![build](https://github.com/limited-effort/snfoil-context/actions/workflows/main.yml/badge.svg) [![maintainability](https://api.codeclimate.com/v1/badges/6a7a2f643707c17cb879/maintainability)](https://codeclimate.com/github/limited-effort/snfoil-context/maintainability)
 
-SnFoil Contexts are a simple way to insure a workflow pipeline can be easily established end extended.  It helps by creating workflow, allowing additional in steps at specific intervals, and reacting to a success or failure, you should find your code being more maintainable and testable.
+SnFoil Contexts are a simple way to ensure a workflow pipeline can be easily established end extended.  It helps by creating a workflow, allowing additional steps at specific intervals, and reacting to success or failure, you should find your code being more maintainable and testable.
 
 ## Installation
 
@@ -15,7 +15,47 @@ gem 'snfoil-context'
 ## Usage
 While contexts are powerful, they aren't a magic bullet.  Each function should strive to only contain a single purpose.  This also has the added benefit of outlining some basic tests - if it is in a function it should have a related test.
 
-### Action
+
+### Quickstart Example
+
+```ruby
+require 'snfoil/context'
+
+class TokenContext
+  include SnFoil::Context
+
+  action(:create) { |options| options[:object].save }
+  action(:expire) { |options| options[:object].update(expired_at: Time.current) }
+
+  # inject created_by
+  setup_create { |options| options[:params][:created_by] = entity }
+
+  # initialize token
+  before_create do |options|
+    options[:object] = Token.create(options[:params])
+    options
+  end
+
+  # send token email
+  after_create_success { |options| TokenMailer.new(token: option[:object]) }
+
+  # log expiration error
+  after_expire_failure { |options| ErrorLogger.notify(error: options[:object].errors) }
+end
+```
+
+
+### Initialize
+
+When you `new` up a SnFoil Context you should provide the entity running the actions.  This will usually be a user but you can pass in anything.  This will be accessible from within the context as `entity`.
+
+```ruby
+  TokenContext.new(current_user)
+```
+
+### Actions
+Actions are a group of hookable intervals that create a workflow around a single primary function.
+
 To start you will need to define an action.  
 
 Arguments:
@@ -30,18 +70,32 @@ require 'snfoil/context'
 class TokenContext
   include SnFoil::Context
 
-  action :expire { |options| options[:object].update(expired_at: Time.current) }
+  ...
+
+  action(:expire) { |options| options[:object].update(expired_at: Time.current) }
 end
 ```
 
-This will generate the methods and hooks of the pipeline.  In this example the following get made:
+This will generate the intervals of the pipeline.  In this example the following get made:
 * setup_expire
 * before_expire
 * after_expire_success
 * after_expire_failure
 * after_expire
 
-If you want to reuse the primary action or just prefer methods, you can pass in the method name you would like to call, rather than providing a block.  If a method name and a block is provided, the block is ignored. 
+Now you can trigger the workflow by calling the action as a method on an instance of the context.
+
+```ruby
+class TokenContext
+  include SnFoil::Context
+
+  action(:expire) { |options| options[:object].update(expired_at: Time.current) }
+end
+
+TokenContext.new(current_user).expire(object: current_token)
+```
+
+If you want to reuse the primary action or just prefer methods, you can pass in the method name you would like to call, rather than providing a block.  If a method name and a block are provided, the block is ignored. 
 
 
 ```ruby
@@ -59,10 +113,10 @@ class TokenContext
 end
 ```
 
-#### Primary Actions
-The primary action is the function that determine whether or not the action is successful.  To do this, the primary action must always return a truthy value if the action was successful, or a falsey one if it failed.
+#### Primary Function
+The primary function is the function that determines whether or not the action is successful.  To do this, the primary function must always return a truthy value if the action was successful, or a falsey one if it failed.
 
-The primary action is passed one argument which is the return value of the closest preceeding interval function.
+The primary function is passed one argument which is the return value of the closest preceding interval function.
 
 ```ruby
 # lib/contexts/token_context
@@ -85,67 +139,67 @@ class TokenContext
 end
 ```
 
-#### Intervals
-The following are the intervals SnFoil Contexts sets up in the order they occur.  The suggested uses are just very simply examples.  You can chain contexts to setup very complex interactions in a very easy to manage workflow.
+#### Action Intervals
+The following are the intervals SnFoil Contexts set up in the order they occur.  The suggested uses are just very simple examples.  You can chain contexts to setup very complex interactions in a very easy-to-manage workflow.
 
 <table>
-    <thead>
-        <th>Name</th>
-        <th>Suggested Use</th>
-    </thead>
-    <tbody>
-        <tr>
-            <td>setup_&lt;action&gt;</td>
-            <td>
-              <div>* find or create a model</div>
-              <div>* setup params needed later in the action</div>
-              <div>* set scoping </div>
-            </td>
-        </tr>
-        <tr>
-            <td>before_&lt;action&gt;</td>
-            <td>
-                <div>* alter model or set attributes</div>
-            </td>
-        </tr>
-        <tr>
-            <td>primary action</td>
-            <td>
-                <div>* persist database changes</div>
-                <div>* make primary network call</div>
-            </td>
-        </tr>
-        <tr>
-            <td>after_&lt;action&gt;_success</td>
-            <td>
-              <div>* setup additional relationships</div>
-              <div>* success specific logging</div>
-            </td>
-        </tr>
-        <tr>
-            <td>after_&lt;action&gt;_failure</td>
-            <td>
-              <div>* cleanup failed remenants</div>
-              <div>* call bug tracker</div>
-              <div>* failure specific logging</div>
-            </td>
-        </tr>
-        <tr>
-            <td>after_&lt;action&gt;</td>
-            <td>
-              <div>* perform necessary required cleanup</div>
-              <div>* log outcome</div>
-            </td>
-        </tr>
-    </tbody>
+  <thead>
+    <th>Name</th>
+    <th>Suggested Use</th>
+  </thead>
+  <tbody>
+    <tr>
+      <td>setup_&lt;action&gt;</td>
+      <td>
+        <div>* find or create a model</div>
+        <div>* setup params needed later in the action</div>
+        <div>* set scoping </div>
+      </td>
+    </tr>
+    <tr>
+      <td>before_&lt;action&gt;</td>
+      <td>
+        <div>* alter model or set attributes</div>
+      </td>
+    </tr>
+    <tr>
+      <td>primary action</td>
+      <td>
+        <div>* persist database changes</div>
+        <div>* make primary network call</div>
+      </td>
+    </tr>
+    <tr>
+      <td>after_&lt;action&gt;_success</td>
+      <td>
+        <div>* setup additional relationships</div>
+        <div>* success specific logging</div>
+      </td>
+    </tr>
+    <tr>
+      <td>after_&lt;action&gt;_failure</td>
+      <td>
+        <div>* cleanup failed remenants</div>
+        <div>* call bug tracker</div>
+        <div>* failure specific logging</div>
+      </td>
+    </tr>
+    <tr>
+      <td>after_&lt;action&gt;</td>
+      <td>
+        <div>* perform necessary required cleanup</div>
+        <div>* log outcome</div>
+      </td>
+    </tr>
+  </tbody>
 <table>
 
 
 #### Hook and Method Design
 
-SnFoil Contexts try hard to not store variables longer than necessary.  To facilitate this we have choosen to pass an object (we normally use a hash called options) to each hook and method, and the return from the hook or method is passed down the chain to the next hook or method.  
+SnFoil Contexts try hard to not store variables longer than necessary.  To facilitate this we have chosen to pass an object (we normally use a hash called options) to each hook and method, and the return from the hook or method is passed down the chain to the next hook or method.  
 
-The only method or block that does not get its value passwed down the chain is the primary action - which must always return a truthy value of whether or not the action was successful.
+The only method or block that does not get its value passed down the chain is the primary action - which must always return a truthy value of whether or not the action was successful.
 
 #### Hooks
 Hooks make it very easy to compose multiple actions that need to occur in a specific order.  You can have as many repeated hooks as you would like.  This makes defining single responsibility hooks very simple, and they will get called in the order they are defined.
@@ -156,29 +210,29 @@ Hooks make it very easy to compose multiple actions that need to occur in a spec
 ```ruby
 # Call the webhooks for third party integrations
 after_expire_success do |options|
-    call_webhook_for_model(options[:object])
-    options
+  call_webhook_for_model(options[:object])
+  options
 end
 
 # Commit business logic to internal process
 after_expire_success do |options|
-    finalize_business_logic(options[:object])
-    options
+  finalize_business_logic(options[:object])
+  options
 end
 
 # notify error tracker
 after_expire_error do |options|
-    notify_errors(options[:object].errors)
-    options
+  notify_errors(options[:object].errors)
+  options
 end
 ```
 
 #### Methods
-Methods allow users to create inheritable actions that occur in a specific order.  Methods will always run after their hook counterpart.  Since these are inheritable, you can chain needed actions all the way through the parent heirarchy by using the `super` keyword. 
+Methods allow users to create inheritable actions that occur in a specific order.  Methods will always run after their hook counterpart.  Since these are inheritable, you can chain needed actions through the parent hierarchy by using the `super` keyword.   These are very useful when you need to have something always happen at the end of an Interval.
 
 <strong>Important Note</strong> Methods <u>always</u> need to return the options hash at the end.
 
-<i>Author's opinion:</i> While simplier than hooks, they do not allow for as clean of a composition as hooks.
+<i>Author's opinion:</i> While simpler than hooks, they do not allow for as clean of a composition as hooks.
 
 ##### Example
 
@@ -186,21 +240,21 @@ Methods allow users to create inheritable actions that occur in a specific order
 # Call the webhooks for third party integrations
 # Commit business logic to internal process
 def after_expire_success(**options)
-    options = super
+  options = super
 
-    call_webhook_for_model(options[:object])
-    finalize_business_logic(options[:object])
+  call_webhook_for_model(options[:object])
+  finalize_business_logic(options[:object])
 
-    options
+  options
 end
 
 # notify error tracker
 def after_expire_error(**options)
-    options = super
+  options = super
 
-    notify_errors(options[:object].errors)
+  notify_errors(options[:object].errors)
 
-    options
+  options
 end
 ```
 
@@ -209,10 +263,10 @@ The original purpose of all of SnFoil was to ensure there was a good consistent
 
 These authorization hooks are always called twice.  Once after `setup_<action>` and once after `before_<action>`
 
-The `authorize` method functions much like primary action except the first argument is usually the name of action you are authorizing.
+The `authorize` method functions much like primary action except the first argument is usually the name of the action you are authorizing.
 
 Arguments:
-* `name` - The name of this action to be authorized.  If ommited, all actions without a specific associated authorize will use this one..
+* `name` - The name of this action to be authorized.  If omitted, all actions without a specific associated authorize will use this
 * `with` - Keyword Param - The method name of the primary action.  Either this or a block is required
 * `block` - Block -  The block of the primary action.  Either this or with is required
 
@@ -225,13 +279,13 @@ class TokenContext
 
   action :expire, with: :expire_token
 
-  authorize :expire { |options| options[:entity].is_admin? }
+  authorize(:expire) { |_options| :entity.is_admin? }
 
   ...
 end
 ```
 
-You can also call authorize without an action name.  This will have all action authorize with the provided method or block unless there is a more specific authorize action configured.  Its probably easier explained with an example
+You can also call authorize without an action name.  This will have all action authorize with the provided method or block unless there is a more specific authorize action configured.  It's probably easier explained with an example
 
 
 ```ruby
@@ -245,15 +299,44 @@ class TokenContext
   action :search, with: :query_tokens #=> will authorize by checking the entity is a user
   action :show, with: :find_token #=> will authorize by checking the entity is a user
 
-  authorize :expire { |options| options[:entity].is_admin? }
-  authorize { |options| options[:entity].is_user? }
+  authorize(:expire) { |_options| entity.is_admin? }
+  authorize { |_options| entity.is_user? }
 
   ...
 end
 ```
 
 #### Why before and after?
-Simply to make sure the entity it actually allowed access the primary target and is allowed to make the requested alterations/interactions.
+Simply to make sure the entity is allowed access to the primary target and is allowed to make the requested alterations/interactions.
+
+### Intervals
+There might be a situation where you don't need a before, after, success or failure, and just need a single name pipeline you can hook into. `interval` allows you to create a single action-like segment.
+
+```ruby
+class TokenContext
+  include SnFoil::Context
+
+  interval :demo
+
+  demo do |options|
+    ... # Logic Here
+
+    options
+  end
+
+  demo do |options|
+    ... # Additional Steps here
+
+    options
+  end
+end
+```
+
+Just like for an action SnFoil allows you to define both hooks and a method.  To run this interval you call it using the `run_interval` method.
+
+```ruby
+TokenContext.new(entity).run_interval(:demo, **options)
+```
 
 ## Development
 
@@ -271,4 +354,4 @@ The gem is available as open source under the terms of the [Apache 2 License](ht
 
 ## Code of Conduct
 
-Everyone interacting in the Snfoil::Context project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/limited-effort/snfoil-context/blob/main/CODE_OF_CONDUCT.md).
+Everyone interacting in the Snfoil::Context project's codebases, issue trackers, chat rooms, and mailing lists is expected to follow the [code of conduct](https://github.com/limited-effort/snfoil-context/blob/main/CODE_OF_CONDUCT.md).

data/lib/snfoil/context/structure.rb

@@ -28,15 +28,25 @@ module SnFoil
       extend ActiveSupport::Concern
 
       class_methods do
-        attr_reader :i_authorizations
+        attr_accessor :snfoil_authorizations
 
         def authorize(action_name = nil, with: nil, &block)
-          @i_authorizations ||= {}
+          @snfoil_authorizations ||= {}
           action_name = action_name&.to_sym
 
-          raise SnFoil::Context::Error, "#{name} already has authorize defined for #{action_name || ':default'}" if @i_authorizations[action_name]
+          if @snfoil_authorizations[action_name]
+            raise SnFoil::Context::Error, "#{name} already has authorize defined for #{action_name || ':default'}"
+          end
 
-          @i_authorizations[action_name] = { method: with, block: block }
+          @snfoil_authorizations[action_name] = { method: with, block: block }
+        end
+
+        def inherited(subclass)
+          super
+
+          instance_variables.grep(/@snfoil_.+/).each do |i|
+            subclass.instance_variable_set(i, instance_variable_get(i).dup)
+          end
         end
       end
 
@@ -47,8 +57,8 @@ module SnFoil
       end
 
       def authorize(name, **options)
-        configured_call = self.class.i_authorizations&.fetch(name.to_sym, nil)
-        configured_call ||= self.class.i_authorizations&.fetch(nil, nil)
+        configured_call = self.class.snfoil_authorizations&.fetch(name.to_sym, nil)
+        configured_call ||= self.class.snfoil_authorizations&.fetch(nil, nil)
 
         if configured_call
           run_hook(configured_call, **options)
@@ -65,12 +75,12 @@ module SnFoil
 
         return send(hook[:method], **options) if hook[:method]
 
-        instance_exec options, &hook[:block]
+        instance_exec(**options, &hook[:block])
       end
 
       def hook_valid?(hook, **options)
-        return false if !hook[:if].nil? && hook[:if].call(options) == false
-        return false if !hook[:unless].nil? && hook[:unless].call(options) == true
+        return false if !hook[:if].nil? && hook[:if].call(**options) == false
+        return false if !hook[:unless].nil? && hook[:unless].call(**options) == true
 
         true
       end

data/lib/snfoil/context/version.rb

@@ -16,6 +16,6 @@
 
 module SnFoil
   module Context
-    VERSION = '0.0.2'
+    VERSION = '0.0.4'
   end
 end

data/lib/snfoil/context.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-# Copyright 2021 Matthew Howes
+# Copyright 2021 Matthew Howes, Cliff Campbell
 
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -35,20 +35,27 @@ module SnFoil
 
     class_methods do
       def action(name, with: nil, &block)
-        raise SnFoil::Context::Error, "action #{name} already defined for #{self.name}" if (@defined_actions ||= []).include?(name)
+        raise SnFoil::Context::Error, "action #{name} already defined for #{self.name}" if (@snfoil_actions ||= []).include?(name)
 
-        @defined_actions << name
-        define_workflow_hooks(name)
+        @snfoil_actions << name
+        define_workflow(name)
         define_action_primary(name, with, block)
       end
-    end
 
-    def run_action_group(group_name, **options)
-      hooks = self.class.instance_variable_get("@#{group_name}_hooks") || []
-      options = hooks.reduce(options) { |opts, hook| run_hook(hook, opts) }
-      options = send(group_name, **options) if respond_to?(group_name)
+      def interval(name)
+        define_singleton_methods(name)
+        define_instance_methods(name)
+      end
+
+      def intervals(*names)
+        names.each { |name| interval(name) }
+      end
+    end
 
-      options
+    def run_interval(interval, **options)
+      hooks = self.class.instance_variable_get("@snfoil_#{interval}_hooks") || []
+      options = hooks.reduce(options) { |opts, hook| run_hook(hook, **opts) }
+      send(interval, **options)
     end
 
     private
@@ -56,38 +63,35 @@ module SnFoil
     # rubocop:disable reason:  These are builder/mapping methods that are just too complex to simplify without
     # making them more complex.  If anyone has a better way please let me know
     class_methods do # rubocop:disable Metrics/BlockLength
+      def define_workflow(name)
+        interval format('setup_%s', name)
+        interval format('before_%s', name)
+        interval format('after_%s_success', name)
+        interval format('after_%s_failure', name)
+        interval format('after_%s', name)
+      end
+
       def define_action_primary(name, method, block) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
-        define_method(name) do |**options| # rubocop:disable Metrics/MethodLength
-          options[:action] = name.to_sym
-          options = run_action_group(format('setup_%s', name), **options)
+        define_method(name) do |*_args, **options| # rubocop:disable Metrics/MethodLength
+          options[:action] ||= name.to_sym
+
+          options = run_interval(format('setup_%s', name), **options)
           authorize(name, **options) if respond_to?(:authorize)
 
-          options = run_action_group(format('before_%s', name), **options)
+          options = run_interval(format('before_%s', name), **options)
           authorize(name, **options) if respond_to?(:authorize)
 
           options = if run_action_primary(method, block, **options)
-                      run_action_group(format('after_%s_success', name), **options)
+                      run_interval(format('after_%s_success', name), **options)
                     else
-                      run_action_group(format('after_%s_failure', name), **options)
+                      run_interval(format('after_%s_failure', name), **options)
                     end
-          run_action_group(format('after_%s', name), **options)
+          run_interval(format('after_%s', name), **options)
         end
       end
 
-      def define_workflow_hooks(name)
-        hook_builder('setup_%s', name)
-        hook_builder('before_%s', name)
-        hook_builder('after_%s_success', name)
-        hook_builder('after_%s_failure', name)
-        hook_builder('after_%s', name)
-      end
-
-      def hook_builder(name_format, name)
-        assign_singleton_methods format(name_format, name),
-                                 format("#{name_format}_hooks", name)
-      end
-
-      def assign_singleton_methods(method_name, singleton_var)
+      def define_singleton_methods(method_name)
+        singleton_var = "snfoil_#{method_name}_hooks"
         instance_variable_set("@#{singleton_var}", [])
         define_singleton_method(singleton_var) { instance_variable_get("@#{singleton_var}") }
         define_singleton_method(method_name) do |method = nil, **options, &block|
@@ -99,12 +103,18 @@ module SnFoil
                                                           unless: options[:unless] }
         end
       end
+
+      def define_instance_methods(method_name)
+        define_method(method_name) do |**options|
+          options
+        end
+      end
     end
 
     def run_action_primary(method, block, **options)
       return send(method, **options) if method
 
-      instance_exec options, &block
+      instance_exec(**options, &block)
     end
   end
 end

data/snfoil-context.gemspec

@@ -5,13 +5,13 @@ require_relative 'lib/snfoil/context/version'
 Gem::Specification.new do |spec|
   spec.name          = 'snfoil-context'
   spec.version       = SnFoil::Context::VERSION
-  spec.authors       = ['Matthew Howes']
-  spec.email         = ['howeszy@gmail.com']
+  spec.authors       = ['Matthew Howes', 'Cliff Campbell']
+  spec.email         = ['howeszy@gmail.com', 'cliffcampbell@hey.com']
 
   spec.summary       = 'Setup simple pipelined workflows'
   spec.description   = 'An easy way to make extensible workflows and actions'
   spec.homepage      = 'https://github.com/limited-effort/snfoil-context'
-  spec.license       = 'MIT'
+  spec.license       = 'Apache-2.0'
   spec.required_ruby_version = '>= 2.5.0'
 
   spec.metadata['homepage_uri'] = spec.homepage
@@ -30,6 +30,8 @@ Gem::Specification.new do |spec|
 
   spec.add_dependency 'activesupport', '>= 5.2.6'
 
+  spec.add_development_dependency 'bundle-audit', '~> 0.1.0'
+  spec.add_development_dependency 'fasterer', '~> 0.9.0'
   spec.add_development_dependency 'pry-byebug', '~> 3.9'
   spec.add_development_dependency 'rake', '~> 13.0'
   spec.add_development_dependency 'rspec', '~> 3.10'

metadata

@@ -1,14 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: snfoil-context
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.4
 platform: ruby
 authors:
 - Matthew Howes
+- Cliff Campbell
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-10-14 00:00:00.000000000 Z
+date: 2021-10-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -24,6 +25,34 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 5.2.6
+- !ruby/object:Gem::Dependency
+  name: bundle-audit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+- !ruby/object:Gem::Dependency
+  name: fasterer
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.0
 - !ruby/object:Gem::Dependency
   name: pry-byebug
   requirement: !ruby/object:Gem::Requirement
@@ -111,10 +140,12 @@ dependencies:
 description: An easy way to make extensible workflows and actions
 email:
 - howeszy@gmail.com
+- cliffcampbell@hey.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".fasterer.yml"
 - ".github/workflows/main.yml"
 - ".gitignore"
 - ".rspec"
@@ -135,7 +166,7 @@ files:
 - snfoil-context.gemspec
 homepage: https://github.com/limited-effort/snfoil-context
 licenses:
-- MIT
+- Apache-2.0
 metadata:
   homepage_uri: https://github.com/limited-effort/snfoil-context
   source_code_uri: https://github.com/limited-effort/snfoil-context