gem_enforcer 0.0.1 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 259683929871f4f3ba6aabed1d4730837860fd2fe0c983f19baf735da1be2edc
-  data.tar.gz: 962e62bd2f891d48b4abf50efe0e44fbb4d43938ef745189c075c5753ca86faf
+  metadata.gz: 743105e56589c3d27eab2fae8e761edde554f552922c43fc474a93be9ed0cfe8
+  data.tar.gz: 0e116051836cfe75a48b444483956e84b705c883a5552e8eda842d8415885f9d
 SHA512:
-  metadata.gz: 86b8b4f2755007c7f1973c2dc844066b4060cc0eb1729906cdabcbd3ad91d17eed1274be1bc3c26a01d6c5459ed660cd547657409b25b844b45d7dc75919e8e0
-  data.tar.gz: debf1f1abd7668a5a36413ee1156b69bba9b0a8d0cb0f4bfd16801c5db74cb58d66e3175a5b1e92d21d1df216a8cebe7da9a0b3db996152aaafef450304d2a4d
+  metadata.gz: 5162dfa82d5e76f7dd6045b2595fb15e913eec2b98e62e60fa4d14cd5db8be9fb565e0b669697485c0a5be84a1fad5cffcabe584f39873309720d9386d9d8965
+  data.tar.gz: fee03c5789429dd03e046b2b9d806e81a3503b1e97117e5ee5bfe559400cc6dbb0a1c436a334ffc5888f6c3acc6e0b2d4140fe42bbe633b32eeaa9b58d16606c

data/Gemfile

@@ -4,8 +4,6 @@ source "https://rubygems.org"
 
 gemspec
 
-gem "faraday", "< 2.6"
-gem 'activesupport'
 gem 'faker'
 gem 'pry'
 gem 'rspec', '~> 3.0'

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    gem_enforcer (0.0.1)
+    gem_enforcer (0.1.0)
       class_composer (>= 1.0)
       faraday
       octokit
@@ -9,28 +9,14 @@ PATH
 GEM
   remote: https://rubygems.org/
   specs:
-    activesupport (7.1.4)
-      base64
-      bigdecimal
-      concurrent-ruby (~> 1.0, >= 1.0.2)
-      connection_pool (>= 2.2.5)
-      drb
-      i18n (>= 1.6, < 2)
-      minitest (>= 5.1)
-      mutex_m
-      tzinfo (~> 2.0)
     addressable (2.8.7)
       public_suffix (>= 2.0.2, < 7.0)
-    base64 (0.2.0)
-    bigdecimal (3.1.8)
     byebug (11.1.3)
     class_composer (1.0.2)
     coderay (1.1.3)
     concurrent-ruby (1.3.4)
-    connection_pool (2.4.1)
     diff-lcs (1.5.1)
     docile (1.4.1)
-    drb (2.2.1)
     faker (3.4.2)
       i18n (>= 1.8.11, < 2)
     faraday (2.5.2)
@@ -40,8 +26,6 @@ GEM
     i18n (1.14.5)
       concurrent-ruby (~> 1.0)
     method_source (1.1.0)
-    minitest (5.25.1)
-    mutex_m (0.2.0)
     octokit (9.1.0)
       faraday (>= 1, < 3)
       sawyer (~> 0.9)
@@ -78,17 +62,13 @@ GEM
       simplecov_json_formatter (~> 0.1)
     simplecov-html (0.13.0)
     simplecov_json_formatter (0.1.4)
-    tzinfo (2.0.6)
-      concurrent-ruby (~> 1.0)
 
 PLATFORMS
   aarch64-linux
   ruby
 
 DEPENDENCIES
-  activesupport
   faker
-  faraday (< 2.6)
   gem_enforcer!
   pry
   pry-byebug

data/README.md

@@ -1,6 +1,15 @@
 # GemEnforcer
 
-`GemEnforcer` is
+`GemEnforcer` is intended to ensure that your ruby scripts services or gems are using an acceptable version of specific gems. In the event that the gem is out of compliance, GemEnforcer can exit or raise an error before continuing.
+
+## Inspiration
+
+I build a lot of scripts that live locally and on other developers laptops. It is hard to ensure that they know when a new version of a critical gem has been realeased. With GemEnforcer, after upgrading, I can enforce the developer is using:
+- One of the 3 most recently released versions of Sidekiq
+- Within 3 minor versions of the most recently released Major version
+- The most recent patch vesion of a current minor version
+- And so many more combinations
+
 
 ## Installation
 
@@ -18,16 +27,54 @@ Or install it yourself as:
 
     $ gem install gem_enforcer
 
+### Create a Configuration File
+
+[Check out Configuration examples](examples)
+
+### Configure the Gem
+
+Prior to running the validation, you can set custom configurations to tailor the GemEnforcement experience
+
+```ruby
+GemEnforcer.configuration do |config|
+  # TO use Git Tags, the access token must be provided
+  # As a default it will check ENV["GITHUB_TOKEN"] or ENV["BUNDLE_GITHUB__COM"] if it is there
+  # If not, it must be provided to use git tag
+  config.github_access_token = "my_access_token"
+
+  config.yml_config_path = "The path to your config file"
+  config.logger = MyLoggerClass #TTY::Logger or Logger classes allowed
+end
+```
+
+### Run Validation
+
+Validations can get run anywhere in your code. Suggested for it to run early on during boot process
+
+```ruby
+# Run configuration validations
+unless GemEnforcer::Setup.validate_yml!
+  # There are errors in the configuration
+  puts GemEnforcer::Setup.errors
+end
+
+# Run the validations based on the config file
+# If validate_yml! failed, this will raise an error!
+GemEnforcer::Setup.run_validations!
+```
 
 ## Development
 
-This gem can be developed against local machine or while using docker. Simpleified Docker commands can be found in the `Makefile` or execute `make help`
+This Gem is very close to 100% test coverage. To understand the inner workings, I would start with the test cases
+
+You can run this gem using docker with make commands (`make bash`) or just on your local machine running at least Ruby 3.2.
+
 
 ## Contributing
 
 This gem welcomes contribution.
 
 Bug reports and pull requests are welcome on GitHub at
-https://github.com/matt-taylor/json_schematize.
+https://github.com/matt-taylor/gem_enforcer.
 
 

data/examples/README.md

@@ -0,0 +1,19 @@
+# Examples
+
+## [Single Validation Example](git_tag.yml)
+
+This is the most basic example. GemEnforcment provides some sane defaults for you to get going quickly. With minimal information, you can start enforcing gem versioning in your script, gem, or application!
+
+## [Enforcement with Multiple Behaviors Example](multiple_behavior.yml)
+
+Multiple behaviors can be super helpful when you want to send a warning before the nuclear option of exiting or raising an error. Using multiple behaviors you can stack the experience and layer multiple warnings on when the Enforcment becomes more forceful
+
+(Also shows a basic example of how a single config can support multiple gem validations)
+
+## [Git Tag with SemVer Example](git_tag.yml)
+
+### Git Tag
+Git Tags allow you to query the version list from git tags. This can help the gem you care about is not in a gem source but rather just in git
+
+### SemVer Version Enforcement
+SemVer versioning enforcment allows you to tailor the Gem Enforcement. Based on the Major, Minor, and/or Patch version of the current gem, you can set individual requirements to meet your needs

data/examples/git_tag.yml

@@ -0,0 +1,26 @@
+# This config file will ensure rails_base gem is up to date based on SemVer specifics
+# NOTE: Usage of git is a bit more expensive and will consume Github API get operations that are counted towards rate limit
+# Major:
+# Major version is set to 0. This will enforce that the gem is up to date with the latest major.
+# If the current major version does not equal what is  released, failure behavior is triggered
+#
+# Patch:
+# Given the current versions major.minor, the patch version is expected to be within the most 2 recent releases
+# If not, it will trigger a failure
+#
+# Notice that minor is missing. This means it does not matter what minor version the current gem is on only that it is
+# on the most recent major version and within 2 of the most recent patches released for the given minor version
+#
+# On Failure:
+# Using log level Error, output the default message and then raise an error
+---
+gems:
+  rails_base: # Enforce the gem rails_base
+    git: matt-taylor # Using git tags where the owner is matt-taylor and the gem name is rails_base
+    behaviors: # Array of different behavior -- Order matters here
+      - version_enforce:
+          major: 0 # Must be on at least the most recent major version
+          patch: 2 # For the given current major.minor version, must be within at least 2 patches
+        on_failure:
+          log_level: error # Log Level to output (This can be a custom log level based on your logger)
+          behavior: raise

data/examples/multiple_behavior.yml

@@ -0,0 +1,40 @@
+# This config file will ensure Rails gem is up to date with the most recent release
+# It uses the default rubygems.org ruby server to query versions against
+# It has two behaviors
+# Behavior 1:
+# => Must be within the last 3 releases
+# => When not within last 3 releases, it will log message and exit immediately
+# Behavior 2:
+# => Must be within the last 2 releases
+# => When not within last 2 releases, it will log message and continue
+# => Behavior is seen as a warning
+#
+# With multiple behaviors, order is important. If order was switched, if more than 3 releases behind,
+# both messages would be shown to user instead of just one
+# => Log Message via ERROR
+# => Do nothing
+
+# Config can support multiple gems!!
+---
+gems:
+  rails: # Enforce the gem Rails
+    server: true # Use the default gem server (https://rubygems.org)
+    behaviors: # Array of different behavior -- Order matters here
+      - version_enforce:
+          releases: 3 # Behavior 1 will trigger when the current version is greater than the 3rd most recent and beyond
+        on_failure:
+          log_level: error # Log Level to output (This can be a custom log level based on your logger)
+          # message: Custom Message to output # There is a default message and this is optional but takes precedence
+          behavior: exit # When behavior is triggered, exit the application immediately
+      - version_enforce:
+          releases: 2 # Behavior 2 will trigger when the current version is 2nd most recent and beyond
+        on_failure:
+          log_level: warn # Log Level to output (This can be a custom log level based on your logger)
+          # Message can have interpolated strings: `version` => current version, `versions_behind` => versions behind, `max_version` => most recent version
+          message: "You are running rails v%{version} which is %{versions_behind} versions behind. Please consider updating"
+
+  sidekiq:
+    server: https://rubygems.org # Input your custom server here
+    behaviors:
+      - version_enforce:
+          insync: true # Behavior 1 triggered as soon as version is not the most recent

data/examples/single_validation.yml

@@ -0,0 +1,14 @@
+# This config file will ensure Sidekiq gem is up to date with the most recent release
+# When this is not met, it will use the default failure behavior
+# => Log Message via ERROR
+# => Do nothing
+---
+gems:
+  sidekiq:
+    server: https://rubygems.org # Input your custom server here
+    behaviors:
+      - version_enforce:
+          insync: true # Behavior 1 triggered as soon as version is not the most recent
+        # on_failure: This is the default on_failure behavior when none is provided
+        #   log_level: error
+        #   behavior: # none Logs message and returns

data/gem_enforcer.gemspec

@@ -36,5 +36,4 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "pry-byebug"
   spec.add_development_dependency "rake", "~> 12.0"
   spec.add_development_dependency "rspec", "~> 3.0"
-  spec.add_development_dependency "simplecov", "~> 0.17.0"
 end

data/gem_enforcer.yml

@@ -4,56 +4,56 @@ invalid_config:
   behavior: exit
 gems:
   rails:
-    on_failure:
-      log_level: warn # on failure, log a warn message
-      behavior: exit
-    version_threshold:
-      minor: 3 # within the last 3 minor releases
+    behaviors:
+      - on_failure:
+          log_level: warn # on failure, log a warn message
+          behavior: exit
+        version_enforce:
+          minor: 3 # within the last 3 minor releases
     server: true # when set to true, defaults to https://rubygems.org
 
   shoryuken:
-    on_failure:
-      log_level: info # on failure, log a info message
-      behavior: skip
-    version_threshold:
-      # Must be within the most current version released
-      # If above is true, must be within the last 2 minor releases
-      # If above is true, must be within the last 3 patches released
-      major: 0 # within the current major version
-      minor: 2 # within the last 3 minor releases
-      patch: 3 # within the last 3 patches released
+    behaviors:
+      - on_failure:
+          log_level: info # on failure, log a info message
+        version_enforce:
+          # Must be within the most current version released
+          # If above is true, must be within the last 2 minor releases
+          # If above is true, must be within the last 3 patches released
+          major: 0 # within the current major version
+          minor: 2 # within the last 3 minor releases
+          patch: 3 # within the last 3 patches released
     server: true # when set to true, defaults to https://rubygems.org
 
   redis:
-    on_failure:
-      log_level: error
-      behavior: raise # on failure, log error and exit(1)
-    enforce_insync: true # Ensure gem is up to date
-    server:
-      source: https://rubygems.org
+    behaviors:
+      - on_failure:
+          log_level: error
+          behavior: raise # on failure, log error and exit(1)
+        version_enforce:
+          insync: true # Ensure gem is up to date
+    server: https://rubygems.org
 
   faraday:
-    on_failure:
-      log_level: error
-      behavior: exit # on failure, log error and exit(1)
-    enforce_insync: true
-    # version_threshold:
-
-      # For most gems, this is effectively the same as `enforce_insync: true`
-      # major: 0
-      # minor: 6
-      # patch: 0
-    server:
-      source: https://rubygems.org
+    behaviors:
+      - on_failure:
+          log_level: error
+          behavior: exit # on failure, log error and exit(1)
+        version_enforce:
+          insync: true # Ensure gem is up to date
+    server: https://rubygems.org
 
   custom_gem:
-    enforce_insync: true
+    behaviors:
+      - version_enforce:
+          insync: true
     server: true
+
   sidekiq:
-    version_threshold:
-      releases: 5 # within the last 5 releases
-    git:
-      owner: sidekiq # Github root page for the gem
+    behaviors:
+      - version_enforce:
+          insync: truee
+    git: sidekiq # Github root page for the gem
 
 
 

data/lib/gem_enforcer/errors.rb

@@ -2,5 +2,6 @@
 
 module GemEnforcer
   class Error < StandardError; end
+  class ConfigError < Error; end
   class ValidationError < Error; end
 end

data/lib/gem_enforcer/setup/behavior.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+
+require "gem_enforcer/setup/helper/on_failure"
+require "gem_enforcer/setup/helper/version_enforcer"
+
+module GemEnforcer
+  module Setup
+    class Behavior
+      attr_reader :gem_name, :params, :index
+
+      def initialize(gem_name:, index:, **params)
+        @gem_name = gem_name
+        @index = index
+        @params = params.transform_keys(&:to_sym)
+      end
+
+      def valid_config?
+        @valid_config ||= validate_config
+      end
+
+      def run_behavior!(version_list:, version:)
+        unless valid_config?
+          raise ConfigError, "Attempted to run validations with invalid Version Configurations"
+        end
+
+        return true if version.nil?
+        return true if version_enforcer.valid_gem_versions?(version_list:, version:)
+
+        false
+      end
+
+      def error_status
+        return nil if errors.empty?
+
+        errors.map { "behaviors[#{index}].#{_1}" }
+      end
+
+      def version_enforcer
+        @version_enforcer ||= Helper::VersionEnforcer.new(gem_name:, version_enforce: params[:version_enforce])
+      end
+
+      def on_failure
+        @on_failure ||= Helper::OnFailure.new(gem_name:, on_failure: params[:on_failure])
+      end
+
+      def run_failure!(message:, version:, version_list:)
+        params = {
+          version:,
+          c: version_list.max,
+          versions_behind: version_enforcer.versions_behind(version_list:, version:),
+        }
+        on_failure.run_on_failure!(message:, **params)
+      end
+
+      private
+
+      def errors
+        @errors ||= []
+      end
+
+      def validate_config
+        boolean = version_enforcer.valid_config?
+        boolean &= on_failure.valid_config?
+
+        @errors = Array(version_enforcer.errors).compact + Array(on_failure.errors).compact
+        @errors.length == 0
+      end
+    end
+  end
+end

data/lib/gem_enforcer/setup/helper/on_failure.rb

@@ -3,54 +3,78 @@
 module GemEnforcer
   module Setup
     module Helper
-      module OnFailure
-        ALLOWED_ON_FAILURE = [:raise, :exit, DEFAULT_BEHAVIOR = :none]
+      class OnFailure
+        attr_reader :gem_name, :on_failure
+
+        ALLOWED_KEYS = [LOG_LEVEL = :log_level, FAILURE_BEHAVIOR = :behavior, MESSAGE = :message]
+        ALLOWED_FAILURE_BEHAVIOR = [:raise, :exit, DEFAULT_BEHAVIOR = :none]
         DEFAULT_LOG_LEVEL = :error
 
-        def validate_on_failure
-          on_failure = params["on_failure"]
-          if on_failure.nil?
-            @on_failure_log_level = DEFAULT_LOG_LEVEL
-            @on_failure_behavior = DEFAULT_BEHAVIOR
-            return true
+        def initialize(gem_name:, on_failure:)
+          @gem_name = gem_name
+          @on_failure = on_failure.transform_keys(&:to_sym) rescue on_failure
+        end
+
+        def valid_config?
+          @valid_config ||= validate_config
+        end
+
+        def errors
+          @errors ||= []
+        end
+
+        def run_on_failure!(message:, **params)
+          unless valid_config?
+            raise ConfigError, "Attempted to run on_failure with an invalid config."
           end
 
-          if Hash === on_failure
-            @on_failure_log_level = on_failure.fetch("log_level", DEFAULT_LOG_LEVEL)
-            behavior = on_failure.fetch("behavior", DEFAULT_BEHAVIOR).to_sym rescue nil
-            if ALLOWED_ON_FAILURE.include?(behavior)
-              @on_failure_behavior = behavior
-              return true
-            else
-              errors << "on_failure.behavior: Expected behavior to be in #{ALLOWED_ON_FAILURE}"
-              return false
-            end
+          send_message = (provided_message || message) % params
+          GemEnforcer.logger.public_send(on_failure_log_level, send_message)
+
+          case on_failure_behavior.to_sym
+          when :raise
+            raise ValidationError, send_message
+          when :exit
+            Kernel.exit(1)
           end
 
-          errors << "on_failure: Expected value hash with :behavior and/or :log_level keys"
-          false
+          true
         end
 
-        def on_failure_default_message
-          message = params.dig("on_failure", "message") rescue nil
-          return message if message
+        private
 
-          version_default_message
+        def on_failure_behavior
+          (on_failure[FAILURE_BEHAVIOR] || DEFAULT_BEHAVIOR) rescue DEFAULT_BEHAVIOR
         end
 
-        def on_failure_behavior(msg:)
+        def on_failure_log_level
+          (on_failure[LOG_LEVEL] || DEFAULT_LOG_LEVEL) rescue DEFAULT_LOG_LEVEL
+        end
 
+        def provided_message
+          on_failure[MESSAGE] rescue nil
         end
 
-        def execute_on_failure!(behavior:, msg: on_failure_default_message)
-          GemEnforcer.logger.public_send(@on_failure_log_level, "Validation failed for #{gem_name}. Current Version is #{current_version}. #{msg}")
+        def validate_config
+          return true if on_failure.nil?
 
-          case @on_failure_behavior.to_sym
-          when :raise
-            raise ValidationError, "Validation failed for #{gem_name}. Current Version is #{current_version}. #{msg}"
-          when :exit
-            Kernel.exit(1)
+          unless Hash === on_failure
+            errors << "on_failure: Expected to contain a Hash. Contained a [#{on_failure.class}]"
+            return false
           end
+
+          disallowed_keys = on_failure.keys - ALLOWED_KEYS
+          if disallowed_keys.length > 0
+            errors << "on_failure: Contained unexpected keys. Only #{ALLOWED_KEYS} are allowed. Found #{disallowed_keys}"
+            return false
+          end
+
+          if on_failure[FAILURE_BEHAVIOR] && ALLOWED_FAILURE_BEHAVIOR.none? { _1 == on_failure[FAILURE_BEHAVIOR].to_sym }
+            errors << "on_failure.#{FAILURE_BEHAVIOR}: Value must be one of #{ALLOWED_FAILURE_BEHAVIOR}. Provided [#{on_failure[FAILURE_BEHAVIOR]}] "
+            return false
+          end
+
+          true
         end
       end
     end

data/lib/gem_enforcer/setup/helper/retrieval.rb

@@ -3,56 +3,65 @@
 module GemEnforcer
   module Setup
     module Helper
-      module Retrieval
-        def validate_retrieval
-          if params["server"]
-            @retrieval_method = :server
-            server_result = _server_validate
-            @factory_version_list = Retrieve.server_retrieval_by_source(source: @retrieval_source)
-
-            server_result
-          elsif params["git"]
-            @retrieval_method = :git
-            git_result = _git_validate
-            @factory_version_list = Retrieve.github_retrieval_by_owner(owner: @retrieval_owner)
-
-            git_result
-          else
-            errors << "retrieval: Missing retrieval type. Expected `server` or `git`"
-            false
-          end
+      class Retrieval
+        attr_reader :gem_name, :server, :git, :retrieval_factory
+
+        def initialize(gem_name:, server:, git:)
+          @gem_name = gem_name
+          @server = server
+          @git = git
+        end
+
+        def valid_config?
+          @valid_config ||= validate_config
+        end
+
+        def errors
+          @errors ||= []
         end
 
         def retrieve_version_list
-          @factory_version_list.gem_versions(name: @gem_name).sort
+          unless valid_config?
+            raise ConfigError, "Attempted to run validations with invalid Version Configurations"
+          end
+
+          retrieval_factory.gem_versions(name: gem_name).sort
         end
 
-        def _server_validate
-          server = params.dig("server")
+        private
 
-          if server == true
-            @retrieval_source = GemEnforcer::DEFAULT_SERVER_SOURCE
-            return true
+        def validate_config
+          if server && git
+            errors << "retrieval: `server` and `git` keys present. Must only choose 1"
+            return false
           end
 
-          if Hash === server && server["source"]
-            @retrieval_source = server["source"]
+          if server
+            if server == true
+              @source = GemEnforcer::DEFAULT_SERVER_SOURCE
+            elsif String === server
+              @source = server
+            else
+              errors << "server: Server retrieval provided. Expected `true` or a string of the rubygem source endpoint"
+              return false
+            end
+            @retrieval_factory = Retrieve.server_retrieval_by_source(source: @source)
             return true
           end
 
-          errors << "retrieval.server: Missing source"
-          false
-        end
-
-        def _git_validate
-          git = params.dig("git")
-          if Hash === git && git["owner"]
-            @retrieval_owner = git["owner"]
-            return true
+          if git
+            if String === git
+              @owner = git
+              @retrieval_factory = Retrieve.github_retrieval_by_owner(owner: git)
+              return true
+            else
+              errors << "git: Git retrieval provided. Expected string of the owner/organization of the gem"
+              return false
+            end
           end
 
-          errors << "retrieval.git: Missing owner"
-          false
+          errors << "retrieval: `server` and `git` keys are missing. Must provide 1 retrieval method"
+          return false
         end
       end
     end

data/lib/gem_enforcer/setup/helper/version_enforcer.rb

@@ -0,0 +1,184 @@
+# frozen_string_literal: true
+
+module GemEnforcer
+  module Setup
+    module Helper
+      class VersionEnforcer
+        attr_reader :gem_name, :version_enforce, :error_validation_message
+
+        ALLOWED_VERSION_INSYNC = :insync
+        ALLOWED_VERSION_REALEASE = :releases
+        ALLOWED_VERSION_SEMVER = [MAJOR = :major, MINOR = :minor, PATCH = :patch]
+
+        def initialize(gem_name:, version_enforce:)
+          @gem_name = gem_name
+          @version_enforce = version_enforce.transform_keys(&:to_sym) rescue nil
+        end
+
+        def valid_config?
+          @valid_config ||= validate_config
+        end
+
+        def valid_gem_versions?(version_list:, version:)
+          unless valid_config?
+            raise ConfigError, "Attempted to run validations with invalid Version Configurations"
+          end
+
+          return true if version.nil?
+
+          min_to_max_version_sorted_list = version_list.sort
+          case @version_type
+          when :insync
+            __validation_insync(version_list: min_to_max_version_sorted_list, version:)
+          when :releases
+            __validation_releases(version_list: min_to_max_version_sorted_list, version:)
+          when :semver
+            __validation_semver(version_list: min_to_max_version_sorted_list, version:)
+          end
+        end
+
+        def errors
+          @errors ||= []
+        end
+
+        def versions_behind(version_list:, version:)
+          version_list.sort.reverse.find_index(version)
+        end
+
+        private
+
+        def __validation_insync(version_list:, version:)
+          max_version = version_list.max
+          return true if version >= max_version
+
+          @error_validation_message = "[#{gem_name}] Enforcer expects the most recent version. Version #{version}. Most Recent version #{max_version}"
+
+          false
+        end
+
+        def __validation_releases(version_list:, version:)
+          releases_behind = version_enforce[ALLOWED_VERSION_REALEASE]
+          min_version_allowed = version_list[-releases_behind]
+          return true if version >= min_version_allowed
+
+          if index = version_list.sort.reverse.find_index(version)
+            version_text = "Version [#{version}] is the #{index} oldest version."
+          else
+            version_text = "Version [#{version}] is the was not found in the provided list."
+          end
+
+          @error_validation_message = "[#{gem_name}] Enforcer expects the version to be within the most recent #{releases_behind} versions. #{version_text}"
+          false
+        end
+
+        def __validation_semver(version_list:, version:)
+          if max_major_versions_behind = version_enforce[:major]
+            if error = __threshold_semver_distance(type: :major, number: version.segments[0], list: version_list.map { _1.segments[0] }, threshold: max_major_versions_behind, version: version)
+              @error_validation_message = error
+              return false
+            end
+          end
+
+          if max_minor_versions_behind = version_enforce[:minor]
+            # Select only the minor versions that match the major version
+            current_major_version = version.segments[0]
+            minor_version_check_list = version_list.select { _1.segments[0] == current_major_version }.map { _1.segments[1] }
+            if error = __threshold_semver_distance(type: :minor, number: version.segments[1], list: minor_version_check_list, threshold: max_minor_versions_behind, version: version)
+              @error_validation_message = error
+              return false
+            end
+          end
+
+          if max_patch_versions_behind = version_enforce[:patch]
+            # Select only the patch versions that match the major.minor version
+            current_major_minor_version = version.segments[0..1]
+            patch_version_check_list = version_list.select { _1.segments[0..1] == current_major_minor_version }.map { _1.segments[2] }
+            if error = __threshold_semver_distance(type: :patch, number: version.segments[2], list: patch_version_check_list, threshold: max_patch_versions_behind, version: version)
+              @error_validation_message = error
+              return false
+            end
+          end
+
+          true
+        end
+
+        def __threshold_semver_distance(type:, number:, list:, threshold:, version:)
+          # remove duplicates ans sort in highest to lowest number
+          uniq_list = list.uniq.sort.reverse
+
+          # get the position in the sorted array
+          position_in_sorted_array = uniq_list.find_index(number)
+
+          # if position is less than or equal to the threshold, we are good
+          # otherwise, it is out of compliance
+          return nil if position_in_sorted_array <= threshold
+
+          "[#{gem_name}] Enforcer expects the version to be within #{threshold} #{type} versions of the most recent version. Version is #{version}"
+        end
+
+        def validate_config
+          unless Hash === version_enforce
+            errors << "version_enforce: Must be a hash containing [#{ALLOWED_VERSION_INSYNC}] or [#{ALLOWED_VERSION_REALEASE}] or any of [#{ALLOWED_VERSION_SEMVER}]"
+            return false
+          end
+
+          if version_enforce.keys.include?(ALLOWED_VERSION_INSYNC)
+            @version_type = :insync
+            __validate_config_insync
+          elsif version_enforce.keys.include?(ALLOWED_VERSION_REALEASE)
+            @version_type = :releases
+            __validate_config_releases
+          elsif version_enforce.keys.any? { ALLOWED_VERSION_SEMVER.include?(_1) }
+            @version_type = :semver
+            __validate_config_semver
+          else
+            errors << "version_enforce: Invalid config. Hash must contain [#{ALLOWED_VERSION_INSYNC}] or [#{ALLOWED_VERSION_REALEASE}] or any of [#{ALLOWED_VERSION_SEMVER}]"
+            false
+          end
+        end
+
+        def __validate_config_insync
+          return false unless validate_expected_keys(ALLOWED_VERSION_INSYNC, "insync")
+
+          return true if version_enforce[ALLOWED_VERSION_INSYNC]
+
+          errors << "version_enforce.#{ALLOWED_VERSION_INSYNC}: When key is present, value must be true. Received [#{version_enforce[ALLOWED_VERSION_INSYNC]}]"
+          false
+        end
+
+        def __validate_config_releases
+          return false unless validate_expected_keys(ALLOWED_VERSION_REALEASE, ALLOWED_VERSION_REALEASE)
+
+          validate_integer(version_enforce[ALLOWED_VERSION_REALEASE], ALLOWED_VERSION_REALEASE)
+        end
+
+        def __validate_config_semver
+          return false unless validate_expected_keys(ALLOWED_VERSION_SEMVER, "SemVer")
+
+          boolean = true
+          boolean &= validate_integer(version_enforce[MAJOR], "major") if version_enforce[MAJOR]
+          boolean &= validate_integer(version_enforce[MINOR], "minor") if version_enforce[MINOR]
+          boolean &= validate_integer(version_enforce[PATCH], "patch") if version_enforce[PATCH]
+
+          boolean
+        end
+
+        def validate_expected_keys(allowed, type)
+          disallowed_keys = version_enforce.keys - Array(allowed)
+
+          return true if disallowed_keys.length == 0
+
+          errors << "version_enforce: Unexpected keys present for `#{type}`. Allowed keys [#{allowed}] but received #{version_enforce.keys}. [#{disallowed_keys}] is not allowed"
+          false
+        end
+
+        def validate_integer(val, dig)
+          return true if Integer === val
+
+          errors << "version_enforce.#{dig}: Expected value to be an Integer. Recieved type #{val.class} [#{val}]"
+          false
+        end
+      end
+    end
+  end
+end

data/lib/gem_enforcer/setup/validate.rb

@@ -1,38 +1,37 @@
 # frozen_string_literal: true
 
-require "yaml"
-
+require "gem_enforcer/setup/behavior"
 require "gem_enforcer/setup/helper/retrieval"
-require "gem_enforcer/setup/helper/on_failure"
-require "gem_enforcer/setup/helper/version"
 
 module GemEnforcer
   module Setup
     class Validate
-      attr_reader :gem_name, :params, :validation_status
-
-      include Helper::Retrieval
-      include Helper::OnFailure
-      include Helper::Version
+      attr_reader :gem_name, :params, :behaviors, :retrieval
 
       def initialize(name:, **params)
         @params = params
         @gem_name = name
-
-        @validation_status = validate!
+        @behaviors = []
+        @errors = []
       end
 
-      # Allow behavior to be overridden if desired
-      def run_validation!(behavior: nil)
-        unless validation_status
+      def run_validation!
+        unless valid_config?
           raise Error, "Unable to run validation with invalid config."
         end
-
         return true if current_version.nil?
 
-        return true if version_execute?(version_list: retrieve_version_list)
+        version_list = retrieval.retrieve_version_list
+        passed_behavior, failed_behavior = behaviors.partition { _1.run_behavior!(version_list:, version: current_version) }
+
+        return true if failed_behavior.empty?
+
+
+        failed_behavior.each do |failed|
+          default_message = failed.version_enforcer.error_validation_message
+          failed.run_failure!(message: default_message, version: current_version, version_list: version_list)
+        end
 
-        execute_on_failure!(behavior: behavior)
         false
       end
 
@@ -40,6 +39,10 @@ module GemEnforcer
         Gem.loaded_specs[gem_name]&.version
       end
 
+      def valid_config?
+        @valid_config ||= validate_config
+      end
+
       def error_status
         return nil if errors.empty?
 
@@ -48,17 +51,47 @@ module GemEnforcer
 
       private
 
-      def errors
-        @errors ||= []
-      end
+      def validate_config
+        generate_behaviors!
+        generate_retreival!
+
+        boolean = true
+        if behaviors.length == 0
+          @errors << "behaviors: At least 1 behavior is expected per gem validation"
+          boolean = false
+        else
+          unless behaviors.all? { _1.valid_config? }
+            # at least 1 beavior failed validation
+            behaviors.each do |b|
+              @errors += b.error_status if b.error_status
+            end
+            errors.flatten!
+            boolean = false
+          end
+        end
 
-      def validate!
-        boolean = validate_retrieval
-        boolean &= validate_on_failure
-        boolean &= validate_version
+        unless retrieval.valid_config?
+          @errors += retrieval.errors
+          boolean = false
+        end
 
         boolean
       end
+
+      def generate_behaviors!
+        raw_behaviors = Array(params["behaviors"] || params[:behaviors] || [])
+        raw_behaviors.each_with_index do |behavior, index|
+          @behaviors << Behavior.new(index:, gem_name:, **behavior)
+        end
+      end
+
+      def generate_retreival!
+        @retrieval = Helper::Retrieval.new(gem_name:, server: (params[:server] || params["server"]), git: (params[:git] || params["git"]))
+      end
+
+      def errors
+        @errors ||= []
+      end
     end
   end
 end

data/lib/gem_enforcer/setup.rb

@@ -8,24 +8,37 @@ module GemEnforcer
     module_function
 
     def validate_yml!
-      errors = config_yml["gems"].map do |name, metadata|
+      @errors = config_yml["gems"].map do |name, metadata|
         validator = Validate.new(name: name, **metadata)
         validations << validator
 
-        validator.error_status
-      end.compact
+        validator.error_status unless validator.valid_config?
+      end.flatten.compact
       return true if errors.empty?
 
       log_level = config_yml.dig("invalid_config", "log_level") || "error"
       behavior = config_yml.dig("invalid_config", "behavior") || "exit"
+
+      false
+    end
+
+    def errors
+      @errors ||= []
     end
 
     def validations
       @validations ||= []
     end
 
-    def run_validations!(behavior: nil)
-      validations.each { _1.run_validation!(behavior: behavior) }
+    def run_validations!
+      validations.each { _1.run_validation! }
+    end
+
+    def execute!
+      if validate_yml!
+
+      else
+      end
     end
 
     def config_yml

data/lib/gem_enforcer/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module GemEnforcer
-  VERSION = "0.0.1"
+  VERSION = "0.1.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: gem_enforcer
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.0
 platform: ruby
 authors:
 - Matt Taylor
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2024-09-11 00:00:00.000000000 Z
+date: 2024-09-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: class_composer
@@ -94,20 +94,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.0'
-- !ruby/object:Gem::Dependency
-  name: simplecov
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.17.0
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.17.0
 description: Provide the ability to validate targetted gems are up to date before
   executing commands
 email:
@@ -129,6 +115,10 @@ files:
 - README.md
 - bin/console
 - docker-compose.yml
+- examples/README.md
+- examples/git_tag.yml
+- examples/multiple_behavior.yml
+- examples/single_validation.yml
 - gem_enforcer.gemspec
 - gem_enforcer.yml
 - lib/gem_enforcer.rb
@@ -138,9 +128,10 @@ files:
 - lib/gem_enforcer/retrieve/gem_server.rb
 - lib/gem_enforcer/retrieve/git_tag.rb
 - lib/gem_enforcer/setup.rb
+- lib/gem_enforcer/setup/behavior.rb
 - lib/gem_enforcer/setup/helper/on_failure.rb
 - lib/gem_enforcer/setup/helper/retrieval.rb
-- lib/gem_enforcer/setup/helper/version.rb
+- lib/gem_enforcer/setup/helper/version_enforcer.rb
 - lib/gem_enforcer/setup/validate.rb
 - lib/gem_enforcer/version.rb
 homepage: https://github.com/matt-taylor/gem_enforcer

data/lib/gem_enforcer/setup/helper/version.rb

@@ -1,151 +0,0 @@
-# frozen_string_literal: true
-
-module GemEnforcer
-  module Setup
-    module Helper
-      module Version
-        ALLOWED_VERSION_REALEASE = :releases
-        ALLOWED_VERSION_SEMVER = [:major, :minor, :patch]
-        ALLOWED_VERSION_THRESHOLD_KEYS = [ALLOWED_VERSION_REALEASE, *ALLOWED_VERSION_SEMVER]
-
-        def version_default_message
-          @default_version_message
-        end
-
-        def validate_version
-          if params.keys.include?("enforce_insync") && params.keys.include?("version_threshold")
-            errors << "version: Must only contain `enforce_insync` or `version_threshold`"
-            return false
-          end
-
-          if params["enforce_insync"]
-            @version_type = :enforce_insync
-            @default_version_message = "Version must be the most recently released version."
-            return true
-          end
-
-          @version_type = :version_threshold
-          version_threshold_keys = params["version_threshold"]&.keys || []
-          if version_threshold_keys.sort == [ALLOWED_VERSION_REALEASE.to_s].sort
-            @version_threshold = :releases
-            @default_version_message = "Version must be within #{params["version_threshold"]["releases"]} of the most recently released versions"
-            _releases_validate
-          elsif ALLOWED_VERSION_THRESHOLD_KEYS.any? { version_threshold_keys.include?(_1.to_s) }
-            @version_threshold = :semver
-            message = []
-            message << "#{params["version_threshold"]["major"]} major versions"  if params["version_threshold"]["major"]
-            message << "#{params["version_threshold"]["minor"]} minor versions"  if params["version_threshold"]["minor"]
-            message << "#{params["version_threshold"]["patch"]} patch versions"  if params["version_threshold"]["patch"]
-            @default_version_message = "Version must be within #{message.join(" and ")} of the most recent release."
-            _semver_validate
-          else
-            errors << "version.version_threshold: Expected keys to contain [#{ALLOWED_VERSION_REALEASE}] or #{ALLOWED_VERSION_SEMVER}"
-            false
-          end
-        end
-
-        def _semver_validate
-          boolean = true
-          if major = params["version_threshold"]["major"]
-            unless Integer === major
-              boolean = false
-              errors << "version.version_threshold.major: Expected value to be an Integer"
-            end
-          end
-
-          if minor = params["version_threshold"]["minor"]
-            unless Integer === minor
-              boolean = false
-              errors << "version.version_threshold.minor: Expected value to be an Integer"
-            end
-          end
-
-          if patch = params["version_threshold"]["patch"]
-            unless Integer === patch
-              boolean = false
-              errors << "version.version_threshold.patch: Expected value to be an Integer"
-            end
-          end
-
-          boolean
-        end
-
-        def _releases_validate
-          release_count = params["version_threshold"]["releases"]
-          unless Integer === release_count
-            errors << "version.version_threshold.releases: Expected value to be an Integer"
-            return false
-          end
-
-          true
-        end
-
-        def version_execute?(version_list:)
-          if @version_type == :enforce_insync
-            __validate_enforce_insync?(version_list:)
-          else
-            if @version_threshold == :releases
-              __validate_version_threshold_releases?(version_list:)
-            else
-              __validate_version_threshold_semver?(version_list:)
-            end
-          end
-        end
-
-        def __validate_version_threshold_semver?(version_list:)
-          if max_major_versions_behind = params.dig("version_threshold", "major")
-            return false unless __threshold_semver_distance(type: :major, number: current_version.segments[0], list: version_list.map { _1.segments[0] }, threshold: max_major_versions_behind)
-          end
-
-          if max_minor_versions_behind = params.dig("version_threshold", "minor")
-            # Select only the minor versions that match the major version
-            current_major_version = current_version.segments[0]
-            minor_version_check_list = version_list.select { _1.segments[0] == current_major_version }.map { _1.segments[1] }
-            return false unless __threshold_semver_distance(type: :minor, number: current_version.segments[1], list: minor_version_check_list, threshold: max_minor_versions_behind)
-          end
-
-          if max_patch_versions_behind = params.dig("version_threshold", "patch")
-            # Select only the patch versions that match the major version
-            current_major_minor_version = current_version.segments[0..1]
-            patch_version_check_list = version_list.select { _1.segments[0..1] == current_major_minor_version }.map { _1.segments[2] }
-            return false unless __threshold_semver_distance(type: :patch, number: current_version.segments[2], list: patch_version_check_list, threshold: max_patch_versions_behind)
-          end
-
-          true
-        end
-
-        def __threshold_semver_distance(type:, number:, list:, threshold:)
-          # remove duplicates ans sort in highest to lowest number
-          uniq_list = list.uniq.sort.reverse
-
-          # get the position in the sorted array
-          position_in_sorted_array = uniq_list.find_index(number)
-
-          # if position is less than or equal to the threshold, we are good
-          # otherwise, it is out of compliance
-          return true if position_in_sorted_array <= threshold
-
-          @default_version_message += " Failed to match #{type} version threshold"
-
-          false
-        end
-
-        def __validate_version_threshold_releases?(version_list:)
-          releases_behind = params.dig("version_threshold", "releases").to_i
-
-          min_version_allowed = version_list[-releases_behind]
-          current_version >= min_version_allowed
-        end
-
-        def __validate_enforce_insync?(version_list:)
-          max_version = version_list.max
-          return true if current_version >= max_version
-
-          @default_version_message += " Please upgrade to at least v#{max_version}"
-
-          false
-        end
-      end
-    end
-  end
-end