remind_me 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 8ea5c318524b2dd5b11cb96b2ff7870e469a38bab9c895f3b62eb86c2e229c57
+  data.tar.gz: ac8c013b669d56012c1a3cbac04eb7f363dfc0c1e3a22540800ef6dd7e938acf
+SHA512:
+  metadata.gz: f6a200f413d221cd864a1b33ea2b890fd04c4f4573575c3c48500311c02a148fc7726e50d7c2929c56071e688d609b00fdcd651517e2c5136bb8989d9cb1528b
+  data.tar.gz: c192d2ea83b3f41e003b769d662cb5c3c1df9ee0d03404370f5033f0f8825417c2596755997ae522bc50168b2e5e4f22f4a6ea788def5e65ca401f9c95cc5a20

data/.github/workflows/main.yml

@@ -0,0 +1,27 @@
+name: Tests
+
+on: [push,pull_request]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        ruby: [ "2.3.7", "2.4.10", "2.5.9", "2.6.8", "2.7.4", "3.0.2", "jruby-9.2" ]
+    steps:
+    - uses: actions/checkout@v2
+    - name: Set up Ruby
+      uses: ruby/setup-ruby@v1
+      with:
+        ruby-version: ${{ matrix.ruby }}
+    - name: Bundle install
+      run: |
+        gem install bundler
+        bundle install --jobs=3
+    - name: Run tests (MRI)
+      run: bundle exec rake spec
+      if: "!startsWith(matrix.ruby, 'jruby')"
+    - name: Run tests (JRuby)
+      run: JRUBY_OPTS=--debug bundle exec rake spec
+      if: startsWith(matrix.ruby, 'jruby')

data/.gitignore

@@ -0,0 +1,12 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+/.idea/
+# rspec failure tracking
+.rspec_status
+.ruby-version

data/.rspec

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

data/.rubocop.yml

@@ -0,0 +1,24 @@
+Style/StringLiterals:
+  Enabled: true
+  EnforcedStyle: single_quotes
+
+Style/StringLiteralsInInterpolation:
+  Enabled: true
+  EnforcedStyle: double_quotes
+
+Style/Documentation:
+  Enabled: false
+
+Layout/LineLength:
+  Max: 120
+
+Metrics/MethodLength:
+  Max: 14
+
+AllCops:
+  Exclude:
+    - 'spec/**/*'
+
+Metrics/BlockLength:
+  Exclude:
+    - 'spec/remind_me/reminders/**/*'

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,84 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+We as members, contributors, and leaders pledge to make participation in our community a harassment-free experience for everyone, regardless of age, body size, visible or invisible disability, ethnicity, sex characteristics, gender identity and expression, level of experience, education, socio-economic status, nationality, personal appearance, race, religion, or sexual identity and orientation.
+
+We pledge to act and interact in ways that contribute to an open, welcoming, diverse, inclusive, and healthy community.
+
+## Our Standards
+
+Examples of behavior that contributes to a positive environment for our community include:
+
+* Demonstrating empathy and kindness toward other people
+* Being respectful of differing opinions, viewpoints, and experiences
+* Giving and gracefully accepting constructive feedback
+* Accepting responsibility and apologizing to those affected by our mistakes, and learning from the experience
+* Focusing on what is best not just for us as individuals, but for the overall community
+
+Examples of unacceptable behavior include:
+
+* The use of sexualized language or imagery, and sexual attention or
+  advances of any kind
+* Trolling, insulting or derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or email
+  address, without their explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Enforcement Responsibilities
+
+Community leaders are responsible for clarifying and enforcing our standards of acceptable behavior and will take appropriate and fair corrective action in response to any behavior that they deem inappropriate, threatening, offensive, or harmful.
+
+Community leaders have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct, and will communicate reasons for moderation decisions when appropriate.
+
+## Scope
+
+This Code of Conduct applies within all community spaces, and also applies when an individual is officially representing the community in public spaces. Examples of representing our community include using an official e-mail address, posting via an official social media account, or acting as an appointed representative at an online or offline event.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be reported to the community leaders responsible for enforcement at nikola@deversity.net. All complaints will be reviewed and investigated promptly and fairly.
+
+All community leaders are obligated to respect the privacy and security of the reporter of any incident.
+
+## Enforcement Guidelines
+
+Community leaders will follow these Community Impact Guidelines in determining the consequences for any action they deem in violation of this Code of Conduct:
+
+### 1. Correction
+
+**Community Impact**: Use of inappropriate language or other behavior deemed unprofessional or unwelcome in the community.
+
+**Consequence**: A private, written warning from community leaders, providing clarity around the nature of the violation and an explanation of why the behavior was inappropriate. A public apology may be requested.
+
+### 2. Warning
+
+**Community Impact**: A violation through a single incident or series of actions.
+
+**Consequence**: A warning with consequences for continued behavior. No interaction with the people involved, including unsolicited interaction with those enforcing the Code of Conduct, for a specified period of time. This includes avoiding interactions in community spaces as well as external channels like social media. Violating these terms may lead to a temporary or permanent ban.
+
+### 3. Temporary Ban
+
+**Community Impact**: A serious violation of community standards, including sustained inappropriate behavior.
+
+**Consequence**: A temporary ban from any sort of interaction or public communication with the community for a specified period of time. No public or private interaction with the people involved, including unsolicited interaction with those enforcing the Code of Conduct, is allowed during this period. Violating these terms may lead to a permanent ban.
+
+### 4. Permanent Ban
+
+**Community Impact**: Demonstrating a pattern of violation of community standards, including sustained inappropriate behavior,  harassment of an individual, or aggression toward or disparagement of classes of individuals.
+
+**Consequence**: A permanent ban from any sort of public interaction within the community.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 2.0,
+available at https://www.contributor-covenant.org/version/2/0/code_of_conduct.html.
+
+Community Impact Guidelines were inspired by [Mozilla's code of conduct enforcement ladder](https://github.com/mozilla/diversity).
+
+[homepage]: https://www.contributor-covenant.org
+
+For answers to common questions about this code of conduct, see the FAQ at
+https://www.contributor-covenant.org/faq. Translations are available at https://www.contributor-covenant.org/translations.

data/Gemfile

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,61 @@
+PATH
+  remote: .
+  specs:
+    remind_me (0.2.0)
+      parser (~> 3.0.2.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    ast (2.4.2)
+    diff-lcs (1.4.4)
+    docile (1.3.5)
+    jaro_winkler (1.5.4)
+    json (2.6.1)
+    parallel (1.19.2)
+    parser (3.0.2.0)
+      ast (~> 2.4.1)
+    rainbow (3.0.0)
+    rake (13.0.6)
+    rexml (3.2.5)
+    rspec (3.10.0)
+      rspec-core (~> 3.10.0)
+      rspec-expectations (~> 3.10.0)
+      rspec-mocks (~> 3.10.0)
+    rspec-core (3.10.1)
+      rspec-support (~> 3.10.0)
+    rspec-expectations (3.10.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.10.0)
+    rspec-mocks (3.10.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.10.0)
+    rspec-support (3.10.3)
+    rubocop (0.81.0)
+      jaro_winkler (~> 1.5.1)
+      parallel (~> 1.10)
+      parser (>= 2.7.0.1)
+      rainbow (>= 2.2.2, < 4.0)
+      rexml
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (>= 1.4.0, < 2.0)
+    ruby-progressbar (1.11.0)
+    simplecov (0.17.1)
+      docile (~> 1.1)
+      json (>= 1.8, < 3)
+      simplecov-html (~> 0.10.0)
+    simplecov-html (0.10.2)
+    unicode-display_width (1.8.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  rake
+  remind_me!
+  rspec
+  rubocop
+  simplecov
+
+BUNDLED WITH
+   2.1.4

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2021 nikola
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,189 @@
+# Remind Me
+[![Tests](https://github.com/nikola-maric/remind_me/workflows/Tests/badge.svg?branch=master)](https://github.com/nikola-maric/remind_me/actions?query=workflow%3ATests+branch%3Amaster)
+
+This gem's main purpose is to scan a file or directory for specific comments in the code. Comments are
+specified as a hash with `REMIND_ME:` (with a colon) prefixed to it, for example: 
+`# REMIND_ME: { gem: 'rails', version: '5.2', condition: :gte, message: 'Remove this method once we switch to Rails 5.2'}`.
+
+Idea is that we often get into situations like this: we create some functionality, but know some
+limitations or that we should revisit this part of the code once conditions change, like:
+- _"We should use `Comparable#clamp` once we upgrade to Ruby 2.4"_ 
+- _"This patch won't be needed once we stop using `activerecord-multitenant` gem"_
+- _"Remove this patch if #203 is merged into main after we bump version of `ruby-debug-ide`"_
+- etc.
+
+`TODO`-s are ok,
+but if we are working with large codebase with lots of `TODO`-s sprinkled all over the place
+we will probably never remember to revisit those parts of the code, and that TODO will stay there for
+a looong time.
+
+One of the options is to use something like [todo_or_die](https://github.com/searls/todo_or_die) which will work for these
+use cases, but in my opinion is too invasive: you need to add code to your own code. Approach here is that you can define
+a script or a rake task that will do this check for you, when you want it, for example in a CI environment. 
+Other than that, these are just comments and won't affect your running code in any way.
+
+If conditions are met for at least one reminder, script will print all of them out and abort 
+(stopping your CI pipeline, for example). You should then revisit those parts of the code and either do some housekeeping
+on the code, or remove/change reminder.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'remind_me'
+```
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install remind_me
+
+## Usage
+
+Script supports both single and multiline comments, so any of these will work:
+```ruby
+# REMIND_ME: { gem: 'rails', version: '6', condition: :gte, message: 'Check this once rails 6 is available'}
+def monkey_patch_x
+  1 + 1
+end
+```
+```ruby
+=begin
+  some other comments
+  REMIND_ME: { gem: 'rails', version: '6', condition: :gte, message: 'Check this once rails 6 is available'}
+  more comments here
+=end
+def monkey_patch_x
+  1 + 1
+end
+```
+```ruby
+
+def monkey_patch_x
+  1 + 1 # REMIND_ME: { ruby_version: '2.4', condition: :gte, message: 'Check this once Ruby is >= 2.4'}
+end
+```
+
+**Important note**: in order to find and parse those comments properly, there are some limitations on how comments are used:
+- Entire `REMIND_ME: {}` comment needs to be on a single line, don't break it into multiple lines.
+- Thing after `REMIND_ME:` needs to have ruby hash structure
+- Both keys and values should be strings, symbols or strings/symbols, depending on reminder (for example, keys can
+be given as symbols, but for `version` values strings are only allowed)
+
+Each reminder type has a specific key that it "targets", for example `ruby_version`. If comment is found that does not 
+match any reminder, we will print out error message specifying that + location where that reminder is found.
+
+Same will happen if reminder is not a hash, or does not have required structure (
+`REMIND_ME: { gem => ->() {exit(1)}.call }`), is unparsable (`REMIND_ME: {{ bla }`) or does not apply
+to any known reminder processor.
+
+### Supported reminder types
+
+**GemVersionReminder**
+
+Has following structure: 
+`REMIND_ME: { gem: 'rails', version: '6', condition: :gte, message: 'Check this once rails 6 is available'}`.  
+It targets all comment hash-es that have `gem/'gem'` in them as a key. 
+It will look at currently installed gems and compare that version to target version specified in comment.
+
+If version is omitted, we will only check if gem is installed or not (can be used to trigger
+reminder when we add new gem). 
+
+If condition is omitted, it will default to `eq`.  
+
+if message is omitted, it will default to `'Condition met!'`
+
+**MissingGemReminder**
+
+Has following structure:
+`REMIND_ME: { missing_gem: 'thor', message: 'Check this once we remove 'thor' gem'}`.  
+It targets all comment hash-es that have `missing_gem/'missing_gem'` in them as a key.
+It will look at currently installed gems and check to see if gem is installed, and will be triggered
+if its not.
+
+if message is omitted, it will default to `'Condition met!'`
+
+**RubyVersionReminder**
+
+Has following structure:
+`REMIND_ME: { ruby_version: '3', condition: :gte, message: 'Check this once we start using Ruby 3.0+'}`.  
+It targets all comment hash-es that have `ruby_version/'ruby_version'` in them as a key.
+It will look at currently used ruby version and compare that version to target version specified in comment.
+
+If condition is omitted, it will default to `eq`.
+
+if message is omitted, it will default to `'Condition met!'`
+
+### Usage example
+Single rake task is added to Rails project, if gem is included in Rails-based project. You can call it with
+`bundle exec rake remind_me:check_reminders`. It will use `.` directory by default, if you need to customize this
+add specific task in one of your `.rake` files and specify another directory, like so:
+```ruby
+require 'remind_me'
+
+desc 'picks up REMIND_ME comments from codebase and checks if their conditions are met'
+task custom_check_reminders: :environment do
+  RemindMe::Runner.new.check_reminders('/some/other/directory/')
+end
+```
+
+If `Rails` is defined, `Rails.logger` will be used for printing results, otherwise `puts` will be used. Make sure your Rails logger
+is configured to work properly from within rake task.
+
+## Adding custom reminders
+You can define custom reminders in your code by registering your reminder class with `RemindMe::Reminder::Generator`. For example:
+```ruby
+# in initializers/timed_reminder.rb
+module Timed
+  class Reminder < RemindMe::Reminder::BaseReminder
+    apply_to_hash_with %i[after_time]
+    validate_hash_ast key: :message, value_types: %i[str], default_value: 'Condition met!'
+
+    def conditions_met?
+      Time.parse(hash_after_time).past?
+    end
+
+    def validation_errors
+      Time.parse(hash_after_time)
+    rescue StandardError => e
+      ["'after_time' holds value that can't be parsed into time (#{e.message})"]
+    end
+  end
+end
+```
+Subclassing `RemindMe::Reminder::BaseReminder` will automatically register it as one of potential reminder processors.
+
+## Future work
+
+Expanding list of available reminders with other useful ones, for example:
+- time based (we want to check something after specified date?)
+- git_tag based ones (maybe we want to revisit something after version X is released?)
+- file gets modified/deleted (when hash changes or file is missing)
+- OS version changes...
+
+Making use of Async ruby, al least for versions that have minimum ruby requirement > 3.0
+(after we fetch all ruby files, creating and looking for reminders should be easily parallelizable)
+
+
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/nikola-maric/remind_me. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/[USERNAME]/remind_me/blob/master/CODE_OF_CONDUCT.md).
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+## Code of Conduct
+
+Everyone interacting in the RemindMe project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/[USERNAME]/remind_me/blob/master/CODE_OF_CONDUCT.md).

data/Rakefile

@@ -0,0 +1,12 @@
+# 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

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'remind_me'
+
+# 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

@@ -0,0 +1,8 @@
+#!/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

data/lib/remind_me/bail_out.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module RemindMe
+  module BailOut
+    class Error < StandardError; end
+
+    def bail_out!(message)
+      raise RemindMe::BailOut::Error, message
+    end
+  end
+end

data/lib/remind_me/railtie.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require 'remind_me'
+require 'rails'
+
+module RemindMe
+  class Railtie < Rails::Railtie
+
+    railtie_name :remind_me
+
+    rake_tasks do
+      path = File.expand_path(__dir__)
+      Dir.glob("#{path}/tasks/**/*.rake").each { |f| load f }
+    end
+
+  end
+end

data/lib/remind_me/reminder/base_reminder.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require_relative '../utils/hash_ast_manipulations'
+require_relative 'generator'
+
+module RemindMe
+  module Reminder
+    class BaseReminder
+      extend RemindMe::Utils::HashASTManipulations
+
+      attr_reader :reminder_comment_ast, :source_location
+
+      def self.inherited(base)
+        RemindMe::Reminder::Generator.register(base)
+        super(base)
+      end
+
+      def conditions_met?
+        raise NotImplementedError
+      end
+
+      def validation_errors
+        []
+      end
+
+      def inspect
+        "#<#{self.class}, source: #{source_location}>"
+      end
+
+      def message
+        "#{hash_message} at #{source_location}"
+      end
+
+      private
+
+      def initialize(reminder_comment_ast, source_location)
+        @reminder_comment_ast = reminder_comment_ast
+        @source_location = source_location
+      end
+    end
+  end
+end

data/lib/remind_me/reminder/gem_version_reminder.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require_relative 'base_reminder'
+require_relative '../utils/versions'
+require_relative '../utils/hash_ast_manipulations'
+
+module RemindMe
+  module Reminder
+    class GemVersionReminder < BaseReminder
+      include RemindMe::Utils::Versions
+
+      apply_to_hash_with %i[gem]
+
+      validate_hash_ast key: :gem, value_types: %i[str sym]
+      validate_hash_ast key: :version, value_types: %i[str]
+      validate_hash_ast key: :message, value_types: %i[str], default_value: 'Condition met!'
+      validate_hash_ast key: :condition, value_types: %i[sym str], default_value: :eq
+
+      def conditions_met?
+        target_version = hash_version
+        # if no version is specified, look for any version
+        if target_version.nil? || target_version.empty?
+          gem_installed?(hash_gem)
+        else
+          return false unless INSTALLED_GEMS[hash_gem]
+
+          condition = hash_condition
+          target_gem_version = Gem::Version.new(target_version)
+          installed_gem_version = INSTALLED_GEMS[hash_gem]
+          compare_version_numbers(target_gem_version, installed_gem_version, condition.to_sym)
+        end
+      end
+
+      def validation_errors
+        errors = super
+        errors << gem_missing_message unless gem_installed?(hash_gem)
+        errors << invalid_condition_message(source_location, hash_condition) unless valid_condition?(hash_condition)
+        errors << malformed_version_string_message unless valid_version_string?(hash_version)
+        errors
+      end
+
+      private
+
+      def gem_missing_message
+        "REMIND_ME comment in #{source_location} mentions '#{hash_gem}' gem, but that gem is not installed"
+      end
+
+      def malformed_version_string_message
+        "REMIND_ME comment in #{source_location} mentions '#{hash_gem}' gem, but version specified: '#{hash_version}'"\
+        ' is not proper version string'
+      end
+    end
+  end
+end

data/lib/remind_me/reminder/generator.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require_relative 'invalid_reminder'
+
+module RemindMe
+  module Reminder
+    class Generator
+
+      def self.register(reminder_klass)
+        @registered_reminders ||= Set.new
+        @registered_reminders << reminder_klass
+      end
+
+      def self.registered_reminders
+        @registered_reminders.dup
+      end
+
+      def self.load_predefined_reminders
+        predefined_remiders = Dir.entries(File.dirname(__FILE__)).select do |path|
+          !path.end_with?('base_reminder.rb') && path.end_with?('_reminder.rb')
+        end
+        predefined_remiders.each { |f| require_relative f }
+      end
+
+      load_predefined_reminders
+
+      def self.generate(source_location, reminder_comment, parser)
+        parser.reset
+        begin
+          reminder_comment_ast = parser.class.parse(reminder_comment)
+        rescue Parser::SyntaxError => e
+          return [unparsable_reminder(source_location, e)]
+        end
+        relevant_reminders_classes = relevant_reminders_classes(reminder_comment_ast)
+        return [unknown_reminder(source_location, reminder_comment)] if relevant_reminders_classes.empty?
+
+        create_reminders_from(reminder_comment_ast, source_location, relevant_reminders_classes)
+      end
+
+      def self.relevant_reminders_classes(reminder_comment_ast)
+        registered_reminders.select do |reminder_class|
+          reminder_class.applicable_to_ast?(reminder_comment_ast)
+        end
+      end
+
+      def self.create_reminders_from(reminder_comment_ast, source_location, relevant_reminders_classes)
+        relevant_reminders_classes.map do |reminder_class|
+          reminder_class.build_from(reminder_comment_ast, source_location)
+        end
+      end
+
+      def self.unknown_reminder(source_location, reminder_comment)
+        RemindMe::Reminder::InvalidReminder
+          .new(source_location,
+               "REMIND_ME comment in #{source_location}: found '#{reminder_comment}' but it was "\
+                 'not applicable to any known reminder processors')
+      end
+
+      def self.unparsable_reminder(source_location, error)
+        RemindMe::Reminder::InvalidReminder
+          .new(source_location,
+               "REMIND_ME comment in #{source_location}: unable to parse, message: #{error.message}")
+      end
+
+      private_class_method :unknown_reminder,
+                           :unparsable_reminder,
+                           :relevant_reminders_classes,
+                           :create_reminders_from
+    end
+  end
+end
+

data/lib/remind_me/reminder/invalid_reminder.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module RemindMe
+  module Reminder
+    class InvalidReminder
+      attr_reader :source_location, :message
+
+      def initialize(source_location, message)
+        @source_location = source_location
+        @message = message
+      end
+    end
+  end
+end

data/lib/remind_me/reminder/missing_gem_reminder.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative 'base_reminder'
+require_relative '../utils/versions'
+
+module RemindMe
+  module Reminder
+    class MissingGemReminder < BaseReminder
+      include RemindMe::Utils::Versions
+
+      apply_to_hash_with %i[missing_gem]
+      validate_hash_ast key: :message, value_types: %i[str], default_value: 'Condition met!'
+
+      def conditions_met?
+        !gem_installed?(hash_missing_gem)
+      end
+
+    end
+  end
+end

data/lib/remind_me/reminder/ruby_version_reminder.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require_relative 'base_reminder'
+require_relative '../utils/versions'
+
+module RemindMe
+  module Reminder
+    class RubyVersionReminder < BaseReminder
+      include RemindMe::Utils::Versions
+
+      apply_to_hash_with %i[ruby_version]
+
+      validate_hash_ast key: :message, value_types: %i[str], default_value: 'Condition met!'
+      validate_hash_ast key: :condition, value_types: %i[sym str], default_value: :eq
+
+      def conditions_met?
+        condition = hash_condition
+        target_ruby_version = Gem::Version.new(hash_ruby_version)
+        installed_ruby_version = Gem::Version.new(RUBY_VERSION)
+        compare_version_numbers(target_ruby_version, installed_ruby_version, condition)
+      end
+
+      def validation_errors
+        errors = super
+        errors << invalid_ruby_version_message if hash_ruby_version.nil? || hash_ruby_version == ''
+        errors << malformed_version_string_message unless valid_version_string?(hash_ruby_version)
+        errors << invalid_condition_message(source_location, hash_condition) unless valid_condition?(hash_condition)
+        errors
+      end
+
+      private
+
+      def invalid_ruby_version_message
+        "REMIND_ME comment on #{source_location} has blank ruby version, you must specify version string"
+      end
+
+      def malformed_version_string_message
+        "REMIND_ME comment in #{source_location} mentions '#{hash_ruby_version}' ruby version, but "\
+        ' that is not a proper version string'
+      end
+    end
+  end
+end

data/lib/remind_me/runner.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require 'parser/current'
+require 'find'
+
+require_relative 'version'
+require_relative 'bail_out'
+require_relative 'reminder/generator'
+require_relative 'utils/logger'
+require_relative 'utils/result_printer'
+
+module RemindMe
+  class Runner
+    include BailOut
+    include Utils::Logger
+
+    attr_reader :parser
+
+    def initialize
+      @parser = Parser::CurrentRuby.new
+      parser.diagnostics.consumer = ->(_message) {  }
+      parser.diagnostics.ignore_warnings = true
+    end
+
+    def check_reminders(check_path: '.')
+      log_info "Checking #{check_path} for any REMIND_ME comments..."
+      all_reminders = collect_reminders(check_path)
+      Utils::ResultPrinter.new(all_reminders).print_results
+    end
+
+    def collect_reminders(parse_path)
+      files = collect_ruby_files(parse_path)
+      bail_out!('Need something to parse!') if files.empty?
+      log_info "Found #{files.size} ruby files"
+      raw_comments = collect_relevant_comments(files)
+      raw_comments.flat_map { |raw_comment| RemindMe::Reminder::Generator.generate(raw_comment[0], raw_comment[1], parser) }
+    end
+
+    private
+
+    def collect_relevant_comments(files)
+      files.flat_map { |file| all_file_comments(file) }
+           .map { |x| [x.location.expression.to_s, x.text.split('REMIND_ME:', 2)] }
+           .select { |x| x[1].size == 2 }
+           .map { |x| [x[0], x[1][1].split("\n").first] }
+    end
+
+    def all_file_comments(file)
+      parser.reset
+      source = File.read(file).force_encoding(parser.default_encoding)
+      buffer = Parser::Source::Buffer.new(file)
+      buffer.source = source
+      parser.parse_with_comments(buffer).last
+    end
+
+    def collect_ruby_files(parse_path)
+      files = []
+      if File.directory?(parse_path)
+        Find.find(parse_path) do |path|
+          files << path if path.end_with? '.rb'
+        end
+      elsif parse_path.end_with? '.rb'
+        files << parse_path
+      end
+      files
+    end
+  end
+end
+

data/lib/remind_me/tasks/remind_me.rake

@@ -0,0 +1,8 @@
+require 'remind_me'
+
+namespace :remind_me do
+  desc 'picks up REMIND_ME comments from codebase and checks if their conditions are met'
+  task check_reminders: :environment do
+    RemindMe::Runner.new.check_reminders
+  end
+end

data/lib/remind_me/utils/hash_ast_manipulations.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+require_relative '../reminder/invalid_reminder'
+
+module RemindMe
+  module Utils
+    module HashASTManipulations
+
+      # Will look for string/symbol keys with specified names in the comment, and if all are found, will return true
+      def apply_to_hash_with(key_values)
+        # Method for determining if we should consider given reminder for this AST
+        define_singleton_method('applicable_to_ast?') do |ast|
+          ast.type == :hash && key_values.all? { |key_value| key_present?(ast, key_value) }
+        end
+        # Building a Reminder from AST, creating invalid one if any of validations returns any non-nil value
+        define_singleton_method('build_from') do |reminder_comment_ast, source_location|
+          create_reminder_from_ast(reminder_comment_ast, source_location)
+        end
+        key_values.each do |key|
+          validate_hash_ast(key: key, value_types: %i[sym str])
+        end
+      end
+
+      def validate_hash_ast(key:, value_types:, **options)
+        @hash_ast_default_values ||= {}
+        @hash_ast_default_values[key] = options[:default_value] if options.key?(:default_value)
+        create_hash_value_accessor_method(key)
+        define_singleton_method("validate_hash_ast_#{key}") do |ast, source_location|
+          return "REMIND_ME comment in #{source_location} is not a Hash" unless ast.type == :hash
+
+          pair = ast_hash_pair(ast, key)
+          # Valid pair was not found...
+          if pair.nil?
+            # ... and we don't have default value set for it
+            unless @hash_ast_default_values.key?(key)
+              "REMIND_ME comment in #{source_location}: value for '#{key}' could not be found, key needs to be "\
+              "either String or Symbol. If not set 'default_value' can be used, but that one was not given as well"
+            end
+            # Pair was found...
+          else
+            # ... but it does not have proper value type
+            unless valid_hash_ast_value?(pair, value_types)
+              "REMIND_ME comment in #{source_location}: value under specified key '#{key}' does not have allowed "\
+              "type (it has '#{hash_ast_pair_value_type(pair)}'), allowed types are #{value_types}"
+            end
+          end
+        end
+      end
+
+      def create_reminder_from_ast(reminder_comment_ast, source_location)
+        # We first perform AST validation
+        ast_validation_errors = singleton_methods.select { |method| method.to_s.start_with?('validate_hash_ast_') }
+                                                 .map { |method| send(method, reminder_comment_ast, source_location) }
+                                                 .compact
+        if ast_validation_errors.empty?
+          # AST looks good, now we perform reminder-specific validations
+          reminder = new(reminder_comment_ast, source_location)
+          validation_errors = reminder.validation_errors
+          if validation_errors.empty?
+            reminder
+          else
+            RemindMe::Reminder::InvalidReminder.new(source_location, validation_errors.join(';'))
+          end
+        else
+          RemindMe::Reminder::InvalidReminder.new(source_location, ast_validation_errors.join(';'))
+        end
+      end
+
+      def create_hash_value_accessor_method(key)
+        return if method_defined?("hash_#{key}")
+
+        send(:define_method, "hash_#{key}") do
+          comment_ast = instance_variable_get('@reminder_comment_ast')
+          value = self.class.hash_ast_pair_value(self.class.ast_hash_pair(comment_ast, key))
+          default_values = self.class.instance_variable_get('@hash_ast_default_values')
+          if (value.nil? || value == '') && default_values.key?(key)
+            default_values[key]
+          else
+            value
+          end
+        end
+      end
+
+      def singleton_method_defined?(method_name)
+        singleton_methods.any? { |method| method.to_s == method_name }
+      end
+
+      def ast_hash_pair(hash_ast, key_value)
+        children_of_type(hash_ast, :pair).find { |pair| valid_hash_ast_key?(pair, key_value) }
+      end
+
+      def key_present?(reminder_comment_ast, key_value)
+        children_of_type(reminder_comment_ast, :pair).any? { |pair| valid_hash_ast_key?(pair, key_value) }
+      end
+
+      def children_of_type(reminder_comment_ast, type)
+        reminder_comment_ast.children.select { |child| child.type.to_s == type.to_s }
+      end
+
+      # key is either a symbol or string
+      def valid_hash_ast_key?(ast_pair, key_value)
+        key = ast_pair.children.first
+        %i[sym str].include?(key.type) && key_value.to_s == key.to_a.first.to_s
+      end
+
+      def valid_hash_ast_value?(ast_pair, allowed_types)
+        value = ast_pair.children[1]
+        allowed_types.include?(value.type)
+      end
+
+      def hash_ast_pair_value_type(ast_pair)
+        ast_pair.children[1].type
+      end
+
+      def hash_ast_pair_value(ast_pair)
+        return nil if ast_pair.nil? || ast_pair.children.nil? || ast_pair.children.size != 2
+
+        ast_pair.children[1].to_a.first
+      end
+    end
+  end
+end

data/lib/remind_me/utils/logger.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module RemindMe
+  module Utils
+    module Logger
+
+      def log_info(msg)
+        rails_being_used? ? log_with_rails(green(msg), :info) : puts(green(msg))
+      end
+
+      def log_error(msg)
+        rails_being_used? ? log_with_rails(red(msg), :error) : puts(red(msg))
+      end
+
+      def colorize(color_code, string)
+        "\e[#{color_code}m#{string}\e[0m"
+      end
+
+      def red(string)
+        colorize(31, string)
+      end
+
+      def green(string)
+        colorize(32, string)
+      end
+
+      def rails_being_used?
+        defined?(Rails)
+      end
+
+      def log_with_rails(msg, severity)
+        Rails.logger.send(severity, msg)
+      end
+    end
+  end
+end

data/lib/remind_me/utils/result_printer.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module RemindMe
+  module Utils
+    class ResultPrinter
+      include Utils::Logger
+
+      attr_reader :reminders
+
+      def initialize(reminders)
+        @reminders = reminders
+      end
+
+      def print_results
+        if reminders.empty?
+          log_info 'No reminders found'
+        else
+          valid_reminders = reminders.reject { |r| r.is_a?(RemindMe::Reminder::InvalidReminder) }
+          invalid_reminders = reminders.select { |r| r.is_a?(RemindMe::Reminder::InvalidReminder) }
+          if invalid_reminders.size.positive?
+            message = invalid_reminders.map(&:message).join("\n")
+            log_error(message)
+            abort
+          else
+            valid_condition_met_reminders = valid_reminders.select(&:conditions_met?)
+            if valid_condition_met_reminders.size.positive?
+              message = valid_condition_met_reminders.map(&:message).join("\n")
+              log_error(message)
+              abort
+            else
+              log_info "Found #{reminders.size} REMIND_ME comment(s), but none of the conditions were met..yet!"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/remind_me/utils/versions.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module RemindMe
+  module Utils
+    module Versions
+      INSTALLED_GEMS = Gem::Specification.map { |a| [a.name, a.version] }.to_h
+
+      def compare_version_numbers(target_version, current_version, comparator)
+        current_version.__send__(condition_comparators[comparator.to_sym], target_version)
+      end
+
+      def gem_installed?(gem)
+        INSTALLED_GEMS.key?(gem.to_s)
+      end
+
+      def valid_condition?(condition)
+        condition_comparators.keys.flat_map { |x| [x, x.to_s] }.include?(condition)
+      end
+
+      def condition_comparators
+        %i[lt lte gt gte eq].zip(%i[< <= > >= ==]).to_h
+      end
+
+      def valid_version_string?(version_string)
+        Gem::Version.new(version_string)
+        true
+      rescue ArgumentError => _e
+        false
+      end
+
+      def invalid_condition_message(source_location, condition)
+        "REMIND_ME comment on #{source_location} has invalid condition: #{condition}, only "\
+        'lt, lte, gt, gte, eq are possible, or you can omit it entirely (it will default to eq)'
+      end
+    end
+  end
+end

data/lib/remind_me/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module RemindMe
+  VERSION = '0.2.0'
+end

data/lib/remind_me.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+require_relative 'remind_me/runner'
+require_relative 'remind_me/railtie' if defined?(Rails::Railtie)
+
+
+
+

data/remind_me.gemspec

@@ -0,0 +1,36 @@
+# encoding: utf-8
+# frozen_string_literal: true
+require_relative 'lib/remind_me/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'remind_me'
+  spec.version       = RemindMe::VERSION
+  spec.authors       = ['Nikola Marić']
+  spec.email         = ['nkl.maric@gmail.net']
+
+  spec.summary       = 'Processor of REMIND_ME comments in the code, reminding us to revisit parts of code'
+  spec.description   = spec.summary
+  spec.homepage      = 'https://github.com/nikola-maric/remind_me'
+  spec.license       = 'MIT'
+  spec.required_ruby_version = Gem::Requirement.new('>= 2.3.0')
+
+  spec.metadata['homepage_uri'] = spec.homepage
+  spec.metadata['source_code_uri'] = spec.homepage
+  spec.metadata['changelog_uri'] = spec.homepage
+
+  # 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
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'rspec'
+  spec.add_development_dependency 'rubocop'
+  spec.add_development_dependency 'simplecov'
+
+  spec.add_dependency 'parser', '~> 3.0.2.0'
+end

metadata

@@ -0,0 +1,147 @@
+--- !ruby/object:Gem::Specification
+name: remind_me
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+platform: ruby
+authors:
+- Nikola Marić
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2021-12-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: parser
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.0.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.0.2.0
+description: Processor of REMIND_ME comments in the code, reminding us to revisit
+  parts of code
+email:
+- nkl.maric@gmail.net
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".github/workflows/main.yml"
+- ".gitignore"
+- ".rspec"
+- ".rubocop.yml"
+- CODE_OF_CONDUCT.md
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/remind_me.rb
+- lib/remind_me/bail_out.rb
+- lib/remind_me/railtie.rb
+- lib/remind_me/reminder/base_reminder.rb
+- lib/remind_me/reminder/gem_version_reminder.rb
+- lib/remind_me/reminder/generator.rb
+- lib/remind_me/reminder/invalid_reminder.rb
+- lib/remind_me/reminder/missing_gem_reminder.rb
+- lib/remind_me/reminder/ruby_version_reminder.rb
+- lib/remind_me/runner.rb
+- lib/remind_me/tasks/remind_me.rake
+- lib/remind_me/utils/hash_ast_manipulations.rb
+- lib/remind_me/utils/logger.rb
+- lib/remind_me/utils/result_printer.rb
+- lib/remind_me/utils/versions.rb
+- lib/remind_me/version.rb
+- remind_me.gemspec
+homepage: https://github.com/nikola-maric/remind_me
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/nikola-maric/remind_me
+  source_code_uri: https://github.com/nikola-maric/remind_me
+  changelog_uri: https://github.com/nikola-maric/remind_me
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.3.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.4
+signing_key: 
+specification_version: 4
+summary: Processor of REMIND_ME comments in the code, reminding us to revisit parts
+  of code
+test_files: []