snfoil-context 0.0.1 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 96734bc3c562904649028a48af86b3bfce1c6afd8273bdf5112dd5e5d608013c
-  data.tar.gz: c380bc1234066ff9d29d6f969214b9d72a57f713ff98a11d64cf969e5310ee02
+  metadata.gz: 865d3b34caed7991d357df2f115087b8c99b84c5e1a0050e691e9bf751149647
+  data.tar.gz: 28c589b8f0fd88f7828c91678de7c58051d1489107ff2c96ad3c94e4c1cfba02
 SHA512:
-  metadata.gz: e6c4262868a512ea479115a6dc709425d7e264b9fbebaabab3134e299ced2e7b089833573d109627e670cffe2edd17cc92ffb9ff19e00f4341bf902b9cdb69e5
-  data.tar.gz: f9eb6db011db1d21437e95c6881a89b9e361310a16952cccf7a57b58ed6342533643622b6379a2eae1cc8a5ab2413a6e69228308cde9b0e58a6ef98da0cd2710
+  metadata.gz: 7115fd9f9bbb8de53f6008fccaa4018f41fc2ce2c13066a7a00e08192d1054589d3c0a471e3be837ac9d26d62cd32088ccc5e39700d7842d954d98d24fb9b9cc
+  data.tar.gz: a7d880bbff1e6cb9fa1fcb39a9f865ebb171d940ec3804ae0ae05a92c97fce9007b480876dcb1b05fab188635f88d28e3e65ea2f37f39d1b8819a3f4e144aacc

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,51 +28,63 @@ 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
-      end
 
-      attr_reader :entity
+        def inherited(subclass)
+          super
 
-      def initialize(entity = nil)
-        @entity = entity
+          instance_variables.grep(/@snfoil_.+/).each do |i|
+            subclass.instance_variable_set(i, instance_variable_get(i).dup)
+          end
+        end
       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)
+      included do
+        attr_reader :entity
 
-        if configured_call
-          run_hook(configured_call, **options)
-        else
-          SnFoil.logger.info "No configuration for #{name} in #{self.class.name}. Authorize not called" if SnFoil.respond_to?(:logger)
-          true
+        def initialize(**keywords)
+          @entity = keywords[:entity]
         end
-      end
 
-      private
+        def authorize(name, **options)
+          configured_call = self.class.snfoil_authorizations&.fetch(name.to_sym, nil)
+          configured_call ||= self.class.snfoil_authorizations&.fetch(nil, nil)
 
-      def run_hook(hook, **options)
-        return options unless hook && hook_valid?(hook, **options)
+          if configured_call
+            run_hook(configured_call, **options)
+          else
+            SnFoil.logger.info "No configuration for #{name} in #{self.class.name}. Authorize not called" if SnFoil.respond_to?(:logger)
+            true
+          end
+        end
 
-        return send(hook[:method], **options) if hook[:method]
+        private
 
-        instance_exec options, &hook[:block]
-      end
+        def run_hook(hook, **options)
+          return options unless hook && hook_valid?(hook, **options)
 
-      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 send(hook[:method], **options) if hook[:method]
 
-        true
+          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
+
+          true
+        end
       end
     end
   end

data/lib/snfoil/context/version.rb

@@ -16,6 +16,6 @@
 
 module SnFoil
   module Context
-    VERSION = '0.0.1'
+    VERSION = '1.0.0'
   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,12 +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
-        setup_hooks(name)
+        @snfoil_actions << name
+        define_workflow(name)
         define_action_primary(name, with, block)
       end
+
+      def interval(name)
+        define_singleton_methods(name)
+        define_instance_methods(name)
+      end
+
+      def intervals(*names)
+        names.each { |name| interval(name) }
+      end
+    end
+
+    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
@@ -48,63 +63,58 @@ 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 "setup_#{name}"
+        interval "before_#{name}"
+        interval "after_#{name}_success"
+        interval "after_#{name}_failure"
+        interval "after_#{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 setup_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|
-          raise SnFoil::Context::ArgumentError, "\##{method_name} requires either a method name or a block" if method.nil? && block.nil?
+        define_singleton_method(method_name) do |with: nil, **options, &block|
+          raise SnFoil::Context::ArgumentError, "\##{method_name} requires either a method name or a block" if with.nil? && block.nil?
 
-          instance_variable_get("@#{singleton_var}") << { method: method,
+          instance_variable_get("@#{singleton_var}") << { method: with,
                                                           block: block,
                                                           if: options[:if],
                                                           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
-    end
-
-    def run_action_group(group_name, **options)
-      options = self.class.instance_variable_get("@#{group_name}_hooks")
-                    .reduce(options) { |opts, hook| run_hook(hook, opts) }
-      options = send(group_name, **options) if respond_to?(group_name)
-
-      options
+      instance_exec(**options, &block)
     end
   end
 end

data/{snfoil-policy.gemspec → snfoil-context.gemspec}

@@ -5,24 +5,24 @@ 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       = ''
-  spec.description   = ''
+  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.required_ruby_version = '>= 2.5.0'
+  spec.license       = 'Apache-2.0'
+  spec.required_ruby_version = '>= 2.7'
 
   spec.metadata['homepage_uri'] = spec.homepage
   spec.metadata['source_code_uri'] = spec.homepage
   spec.metadata['changelog_uri'] = 'https://github.com/limited-effort/snfoil-context/blob/main/CHANGELOG.md'
+  spec.metadata['rubygems_mfa_required'] = 'true'
 
   # Specify which files should be added to the gem when it is released.
   # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
-  spec.files = Dir.chdir(File.expand_path(__dir__)) do
-    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{\A(?:test|spec|features)/}) }
-  end
+  ignore_list = %r{\A(?:test/|spec/|bin/|features/|Rakefile|\.\w)}
+  spec.files = Dir.chdir(File.expand_path(__dir__)) { `git ls-files -z`.split("\x0").reject { |f| f.match(ignore_list) } }
 
   spec.bindir        = 'exe'
   spec.executables   = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
@@ -30,10 +30,12 @@ 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.10.0'
   spec.add_development_dependency 'pry-byebug', '~> 3.9'
   spec.add_development_dependency 'rake', '~> 13.0'
   spec.add_development_dependency 'rspec', '~> 3.10'
-  spec.add_development_dependency 'rubocop', '~> 1.21'
+  spec.add_development_dependency 'rubocop', '~> 1.29'
   spec.add_development_dependency 'rubocop-performance', '~> 1.11'
   spec.add_development_dependency 'rubocop-rspec', '~> 2.5'
 end

metadata

@@ -1,14 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: snfoil-context
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 1.0.0
 platform: ruby
 authors:
 - Matthew Howes
-autorequire: 
+- Cliff Campbell
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-10-12 00:00:00.000000000 Z
+date: 2022-05-11 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.10.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.10.0
 - !ruby/object:Gem::Dependency
   name: pry-byebug
   requirement: !ruby/object:Gem::Requirement
@@ -72,14 +101,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.21'
+        version: '1.29'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.21'
+        version: '1.29'
 - !ruby/object:Gem::Dependency
   name: rubocop-performance
   requirement: !ruby/object:Gem::Requirement
@@ -108,39 +137,34 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2.5'
-description: ''
+description: An easy way to make extensible workflows and actions
 email:
 - howeszy@gmail.com
+- cliffcampbell@hey.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- ".github/workflows/main.yml"
-- ".gitignore"
-- ".rspec"
-- ".rubocop.yml"
 - CHANGELOG.md
 - CODE_OF_CONDUCT.md
 - Gemfile
 - LICENSE.txt
 - README.md
-- Rakefile
-- bin/console
-- bin/setup
 - lib/snfoil/context.rb
 - lib/snfoil/context/argument_error.rb
 - lib/snfoil/context/error.rb
 - lib/snfoil/context/structure.rb
 - lib/snfoil/context/version.rb
-- snfoil-policy.gemspec
+- 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
   changelog_uri: https://github.com/limited-effort/snfoil-context/blob/main/CHANGELOG.md
-post_install_message: 
+  rubygems_mfa_required: 'true'
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -148,7 +172,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.5.0
+      version: '2.7'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
@@ -156,7 +180,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubygems_version: 3.1.6
-signing_key: 
+signing_key:
 specification_version: 4
-summary: ''
+summary: Setup Simple Pipelined Workflows
 test_files: []

data/.github/workflows/main.yml

@@ -1,46 +0,0 @@
-name: build
-on: 
-  push:
-    branches: [ main ]
-  pull_request:
-
-jobs:
-  test:
-
-    runs-on: ubuntu-latest
-
-    strategy:
-      matrix:
-        ruby-version: [2.7, 2.6, 2.5]
-
-    steps:
-      - uses: actions/checkout@v2
-      - name: Set up Ruby ${{ matrix.ruby-version }}
-        uses: ruby/setup-ruby@v1.81.0
-        with:
-          ruby-version: ${{ matrix.ruby-version }}
-          bundler-cache: true
-      - name: Install dependencies
-        run: bundle install
-      - name: Run tests
-        run: bundle exec rspec
-  lint:
-
-    runs-on: ubuntu-latest
-
-    strategy:
-      matrix:
-        ruby-version: [2.7, 2.6, 2.5, '3.0']
-
-    steps:
-      - uses: actions/checkout@v2
-      - name: Set up Ruby ${{ matrix.ruby-version }}
-        uses: ruby/setup-ruby@v1.81.0
-        with:
-          ruby-version: ${{ matrix.ruby-version }}
-          bundler-cache: true
-      - name: Install dependencies
-        run: bundle install
-      - name: Run rubocop
-        run: bundle exec rubocop
-

data/.gitignore

@@ -1,14 +0,0 @@
-/.bundle/
-/.yardoc
-/_yardoc/
-/coverage/
-/doc/
-/pkg/
-/spec/reports/
-/tmp/
-
-# rspec failure tracking
-.rspec_status
-
-# GEMFILE
-Gemfile.lock

data/.rspec

@@ -1,3 +0,0 @@
---format documentation
---color
---require spec_helper

data/.rubocop.yml

@@ -1,39 +0,0 @@
-require:
-  - rubocop-performance
-  - rubocop-rspec
-
-AllCops:
-  NewCops: enable
-  SuggestExtensions: false
-  TargetRubyVersion: 2.5.0
-
-# ================ LAYOUT ==============
-Layout/LineLength:
-  Max: 150
-
-# ================ LINT ================
-Lint/AmbiguousBlockAssociation:
-  Exclude:
-    - spec/**/*_spec.rb
-
-Lint/EmptyClass:
-  Exclude:
-    - spec/**/*_spec.rb
-
-# ================ Metics ================
-Metrics/BlockLength:
-  Exclude:
-    - spec/**/*_spec.rb
-
-# ================ RSPEC ================
-RSpec/FilePath:
-  Enabled: false
-
-RSpec/MultipleExpectations:
-  Max: 5
-
-RSpec/MultipleMemoizedHelpers:
-  Enabled: false
-
-RSpec/NestedGroups:
-  Max: 5

data/Rakefile

@@ -1,12 +0,0 @@
-# frozen_string_literal: true
-
-require 'bundler/gem_tasks'
-require 'rspec/core/rake_task'
-
-RSpec::Core::RakeTask.new(:spec)
-
-require 'rubocop/rake_task'
-
-RuboCop::RakeTask.new
-
-task default: %i[spec rubocop]

data/bin/console

@@ -1,15 +0,0 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-
-require 'bundler/setup'
-require 'snfoil/policy'
-
-# You can add fixtures and/or initialization code here to make experimenting
-# with your gem easier. You can also use a different console, if you like.
-
-# (If you use this, don't forget to add pry to your Gemfile!)
-# require "pry"
-# Pry.start
-
-require 'irb'
-IRB.start(__FILE__)

data/bin/setup

@@ -1,8 +0,0 @@
-#!/usr/bin/env bash
-set -euo pipefail
-IFS=$'\n\t'
-set -vx
-
-bundle install
-
-# Do any other automated setup that you need to do here