end_of_life 0.4.0 → 0.5.0

data/lib/end_of_life/product/release.rb

@@ -0,0 +1,30 @@
+module EndOfLife
+  class Product
+    class Release < Data.define(:product, :version, :eol_date)
+      include Comparable
+
+      def self.ruby(version, eol_date: nil) = new(product: "ruby", version:, eol_date:)
+
+      def initialize(product:, version:, eol_date: nil)
+        product = Product.find(product.to_s)
+        eol_date = Date.parse(eol_date.to_s) if eol_date
+        super(product:, eol_date:, version: Gem::Version.new(version))
+      end
+
+      def eol?(at: Date.today)
+        if eol_date
+          eol_date <= at
+        else
+          self <= product.latest_eol_release(at: at)
+        end
+      end
+
+      ZERO = Gem::Version.new("0")
+      def zero? = version == ZERO
+
+      def <=>(other) = version <=> other.version
+
+      def to_s = version.to_s
+    end
+  end
+end

data/lib/end_of_life/product.rb

@@ -0,0 +1,32 @@
+module EndOfLife
+  class Product
+    def self.find(name) = EndOfLife.find_product(name)
+
+    attr_reader :name, :search_query, :version_detector
+
+    def initialize(name, search_query, version_detector)
+      @name = name.to_s.downcase
+      @search_query = search_query
+      @version_detector = version_detector
+    end
+
+    def eol_releases_at(date)
+      all_releases.filter { |release| release.eol_date <= date }
+    end
+
+    def latest_eol_release(at: Date.today)
+      eol_releases_at(at).max
+    end
+
+    def label = name.capitalize
+    def to_s = label
+
+    private
+
+    def all_releases
+      @all_releases ||= API.fetch_product(name)
+        .dig(:result, :releases)
+        .map { |json| Release.new(name, json[:latest][:name], json[:eolFrom]) }
+    end
+  end
+end

data/lib/end_of_life/report.rb

@@ -0,0 +1,35 @@
+require "stringio"
+
+module EndOfLife
+  class Report < Data.define(:product, :repositories, :max_eol_date)
+    include Helpers::Terminal
+
+    def to_s
+      report = StringIO.new
+      report.puts
+
+      if repositories.empty?
+        report.puts "No repositories using EOL #{product}."
+      else
+        word = (repositories.size == 1) ? "repository" : "repositories"
+        report.puts "Found #{repositories.size} #{word} using EOL #{product} (<= #{product.latest_eol_release(at: max_eol_date)}):"
+        report.puts end_of_life_table(repositories)
+      end
+
+      report.string
+    end
+
+    def failure? = repositories.any?
+
+    private
+
+    def end_of_life_table(repositories)
+      headers = ["", "Repository", "#{product} version"]
+      rows = repositories.map.with_index(1) do |repo, i|
+        [i, repo.url, repo.min_release_of(product)]
+      end
+
+      table(headers, rows)
+    end
+  end
+end

data/lib/end_of_life/repository/search/query.rb

@@ -0,0 +1,31 @@
+module EndOfLife
+  class Repository
+    class Search
+      Query = Data.define(:options) do
+        def to_s
+          query = options[:product].search_query
+
+          query += if options[:repository]
+            " repo:#{options[:repository]}"
+          elsif options[:organizations]
+            options[:organizations].map { |org| " org:#{org}" }.join
+          else
+            " user:#{options[:user]}"
+          end
+
+          if options[:visibility]
+            query += " is:#{options[:visibility]}"
+          end
+
+          if options[:excludes]
+            words_to_exclude = options[:excludes].map { |word| "NOT #{word} " }.join
+
+            query += " #{words_to_exclude} in:name"
+          end
+
+          query
+        end
+      end
+    end
+  end
+end

data/lib/end_of_life/repository/search.rb

@@ -0,0 +1,45 @@
+module EndOfLife
+  class Repository
+    class Search
+      include Dry::Monads[:result, :maybe]
+
+      attr_reader :options
+
+      def initialize(options)
+        @options = options
+      end
+
+      def result
+        github_client.bind do |github|
+          github.auto_paginate = true
+          options[:user] ||= github.user.login
+
+          query = Query.new(options).to_s
+          items = github.search_repositories(query, {sort: :updated}).items
+
+          Success(
+            items.filter_map do |repo|
+              next if repo.archived && options[:skip_archived]
+
+              Repository.new(
+                full_name: repo.full_name,
+                url: repo.html_url,
+                github_client: github
+              )
+            end
+          )
+        rescue => e
+          Failure("Unexpected error: #{e}")
+        end
+      end
+
+      private
+
+      def github_client
+        Maybe(ENV["GITHUB_TOKEN"])
+          .fmap { |token| Octokit::Client.new(access_token: token) }
+          .or { Failure("Please set GITHUB_TOKEN environment variable") }
+      end
+    end
+  end
+end

data/lib/end_of_life/repository.rb

@@ -1,61 +1,7 @@
 module EndOfLife
   class Repository
     class << self
-      include Dry::Monads[:result, :maybe]
-
-      def fetch(options)
-        github_client.bind do |github|
-          github.auto_paginate = true
-          options[:user] ||= github.user.login
-
-          query = search_query_for(options)
-          items = github.search_repositories(query, {sort: :updated}).items
-
-          Success(
-            items.filter_map do |repo|
-              next if repo.archived && options[:skip_archived]
-
-              Repository.new(
-                full_name: repo.full_name,
-                url: repo.html_url,
-                github_client: github
-              )
-            end
-          )
-        rescue => e
-          Failure("Unexpected error: #{e}")
-        end
-      end
-
-      def github_client
-        Maybe(ENV["GITHUB_TOKEN"])
-          .fmap { |token| Octokit::Client.new(access_token: token) }
-          .or { Failure("Please set GITHUB_TOKEN environment variable") }
-      end
-
-      def search_query_for(options)
-        query = "language:ruby"
-
-        query += if options[:repository]
-          " repo:#{options[:repository]}"
-        elsif options[:organizations]
-          options[:organizations].map { |org| " org:#{org}" }.join
-        else
-          " user:#{options[:user]}"
-        end
-
-        if options[:visibility]
-          query += " is:#{options[:visibility]}"
-        end
-
-        if options[:excludes]
-          words_to_exclude = options[:excludes].map { |word| "NOT #{word} " }.join
-
-          query += " #{words_to_exclude} in:name"
-        end
-
-        query
-      end
+      def search(options) = Search.new(options).result
     end
 
     attr_reader :full_name, :url
@@ -64,39 +10,33 @@ module EndOfLife
       @full_name = full_name
       @url = url
       @github_client = github_client
+      @product_releases = {}
     end
 
-    def eol_ruby?(at: Date.today)
-      ruby_version&.eol?(at: at)
+    def using_eol?(product, at: Date.today)
+      min_release_of(product)&.eol?(at: at)
     end
 
-    def ruby_version
-      return @ruby_version if defined?(@ruby_version)
-
-      @ruby_version = ruby_versions.min
-    end
+    def min_release_of(product) = releases_for(product).min
 
     private
 
-    def ruby_versions
-      return @ruby_versions if defined?(@ruby_versions)
-
-      @ruby_versions = fetch_ruby_version_files.filter_map { |file|
-        parse_version_file(file)
-      }
+    def releases_for(product)
+      @product_releases[product] ||= product.version_detector.detect_all(
+        fetch_files(product.version_detector.relevant_files)
+      )
     end
 
-    POSSIBLE_RUBY_VERSION_FILES = [
-      ".ruby-version",
-      "Gemfile.lock",
-      "Gemfile",
-      ".tool-versions"
-    ]
-    def fetch_ruby_version_files
+    def fetch_files(file_paths)
       Sync do
-        POSSIBLE_RUBY_VERSION_FILES
+        file_paths
           .map { |file_path| Async { fetch_file(file_path) } }
-          .filter_map(&:wait)
+          .filter_map { |task|
+            file = task.wait
+            next if file.nil?
+
+            InMemoryFile.new(file.path, decode_file(file))
+          }
       end
     end
 
@@ -106,10 +46,6 @@ module EndOfLife
       nil
     end
 
-    def parse_version_file(file)
-      RubyVersion.from_file(file_name: file.name, content: decode_file(file))
-    end
-
     def decode_file(file)
       return file.content if file.encoding.nil?
       return Base64.decode64(file.content) if file.encoding == "base64"

data/lib/end_of_life/scanner.rb

@@ -0,0 +1,41 @@
+module EndOfLife
+  module Scanner
+    include Helpers::Terminal
+    extend self
+
+    def scan(options)
+      fetch_repositories(options)
+        .fmap { |repositories| filter_repositories_with_eol_products(repositories, **options.slice(:product, :max_eol_date)) }
+        .fmap { |repositories| output_report(repositories, **options.slice(:product, :max_eol_date)) }
+        .or { |error| abort "\n#{error_msg(error)}" }
+    end
+
+    private
+
+    def fetch_repositories(options)
+      with_loading_spinner("Searching repositories with #{options[:product].label}...") do |spinner|
+        result = Repository.search(options)
+        spinner.error if result.failure?
+
+        result
+      end
+    end
+
+    def filter_repositories_with_eol_products(repositories, product:, max_eol_date:)
+      with_loading_spinner("Searching for EOL #{product} in your repositories...") do
+        Sync do
+          repositories
+            .map { |repo| Async { [repo, repo.using_eol?(product, at: max_eol_date)] } }.map(&:wait)
+            .filter_map { |repo, contains_eol| contains_eol ? repo : nil }
+        end
+      end
+    end
+
+    def output_report(repositories, product:, max_eol_date:)
+      report = Report.new(product, repositories, max_eol_date)
+      puts report
+
+      exit(1) if report.failure?
+    end
+  end
+end

data/lib/end_of_life/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module EndOfLife
-  VERSION = "0.4.0"
+  VERSION = "0.5.0"
 end

data/lib/end_of_life/version_detector.rb

@@ -0,0 +1,27 @@
+module EndOfLife
+  module VersionDetector
+    def file_detectors
+      @file_detectors ||= {}
+    end
+
+    def detects_from(file, &block)
+      file_detectors[file] = block
+    end
+
+    def relevant_files = file_detectors.keys
+
+    def detect_all(files)
+      files.filter_map { |file| detect(file) }
+    end
+
+    def detect(file)
+      return if file.read.strip.empty?
+      detector = file_detectors[File.basename(file.path)] or return
+      version = detector.call(file.read) or return
+
+      return if version.zero?
+
+      version
+    end
+  end
+end

data/lib/end_of_life/version_detectors/rails.rb

@@ -0,0 +1,26 @@
+module EndOfLife
+  module VersionDetectors
+    module Rails
+      extend VersionDetector
+
+      detects_from "Gemfile.lock" do |file_content|
+        gemfile_lock = Parsers::GemfileLock.parse(file_content) or next
+        rails = gemfile_lock.specs.find { |it| it.name == "rails" } or next
+
+        Product::Release.new(product: "rails", version: rails.version)
+      end
+
+      detects_from "Gemfile" do |file_content|
+        gemfile = Parsers::Gemfile.parse(file_content) or next
+        rails_dep = gemfile.dependencies.find { |it| it.name == "rails" } or next
+        exact_version = rails_dep
+          .requirement
+          .requirements
+          .filter { |op, _| op == "=" } # standard:disable Style/HashSlice
+          .max_by { |_, version| version } or next
+
+        Product::Release.new(product: "rails", version: exact_version.last)
+      end
+    end
+  end
+end

data/lib/end_of_life/version_detectors/ruby.rb

@@ -0,0 +1,35 @@
+require "bundler"
+
+module EndOfLife
+  module VersionDetectors
+    module Ruby
+      extend VersionDetector
+
+      detects_from ".ruby-version" do |file_content|
+        string_version = Parsers::RubyVersion.parse(file_content)
+
+        Product::Release.ruby(string_version)
+      end
+
+      detects_from "Gemfile.lock" do |file_content|
+        gemfile_lock_version = Parsers::GemfileLock.parse(file_content).ruby_version or next
+
+        Product::Release.ruby(gemfile_lock_version.delete_prefix("ruby "))
+      end
+
+      detects_from "Gemfile" do |file_content|
+        gemfile = Parsers::Gemfile.parse(file_content)
+        gemfile_version = gemfile&.ruby_version&.gem_version or next
+
+        Product::Release.ruby(gemfile_version)
+      end
+
+      detects_from ".tool-versions" do |file_content|
+        tool_versions = Parsers::ToolVersions.parse(file_content)
+        ruby_version = tool_versions["ruby"] or next
+
+        Product::Release.ruby(ruby_version)
+      end
+    end
+  end
+end

data/lib/end_of_life/version_detectors.rb

@@ -0,0 +1,17 @@
+module EndOfLife
+  module VersionDetectors
+    extend self
+
+    def for_product(product)
+      detector_class = "#{self}::#{camelize(product.to_s)}"
+
+      const_get(detector_class)
+    rescue NameError
+      raise ArgumentError, "Undefined version detector for product: #{product}"
+    end
+
+    private
+
+    def camelize(word) = Zeitwerk::Inflector.new.camelize(word, nil)
+  end
+end

data/lib/end_of_life.rb

@@ -5,13 +5,16 @@ require "dry-monads"
 require "json"
 require "base64"
 require "octokit"
-require_relative "end_of_life/options"
-require_relative "end_of_life/repository"
-require_relative "end_of_life/ruby_version"
-require_relative "end_of_life/terminal_helper"
-require_relative "end_of_life/version"
-require_relative "end_of_life/cli"
+require "zeitwerk"
+
+Zeitwerk::Loader.for_gem.tap { |it|
+  it.inflector.inflect("cli" => "CLI", "api" => "API")
+}.setup
 
 module EndOfLife
-  extend TerminalHelper
+  extend Product::Registry
+  extend Helpers::Terminal
+
+  scans_for :ruby, search_query: "language:ruby"
+  scans_for :rails, search_query: "language:ruby"
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: end_of_life
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors:
 - Matheus Richard
 bindir: exe
 cert_chain: []
-date: 2025-05-23 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: async
@@ -93,8 +93,22 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 0.12.0
+- !ruby/object:Gem::Dependency
+  name: zeitwerk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.7'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.7'
 description: Searches your GitHub repositores and lists the ones using end-of-life,
-  i.e. unmaintained, Ruby versions.
+  i.e. unmaintained, software versions.
 email:
 - matheusrichardt@gmail.com
 executables:
@@ -104,7 +118,6 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".rspec"
-- ".standard.yml"
 - ".tool-versions"
 - CHANGELOG.md
 - Gemfile
@@ -118,15 +131,30 @@ files:
 - end_of_life.gemspec
 - exe/end_of_life
 - exe/eol
-- lib/end_of_life.json
 - lib/end_of_life.rb
+- lib/end_of_life/api.rb
 - lib/end_of_life/cli.rb
+- lib/end_of_life/helpers/silent_bundler.rb
+- lib/end_of_life/helpers/terminal.rb
+- lib/end_of_life/in_memory_file.rb
 - lib/end_of_life/options.rb
+- lib/end_of_life/parsers/gemfile.rb
+- lib/end_of_life/parsers/gemfile_lock.rb
+- lib/end_of_life/parsers/ruby_version.rb
+- lib/end_of_life/parsers/tool_versions.rb
+- lib/end_of_life/product.rb
+- lib/end_of_life/product/registry.rb
+- lib/end_of_life/product/release.rb
+- lib/end_of_life/report.rb
 - lib/end_of_life/repository.rb
-- lib/end_of_life/ruby_version.rb
-- lib/end_of_life/ruby_version/parser.rb
-- lib/end_of_life/terminal_helper.rb
+- lib/end_of_life/repository/search.rb
+- lib/end_of_life/repository/search/query.rb
+- lib/end_of_life/scanner.rb
 - lib/end_of_life/version.rb
+- lib/end_of_life/version_detector.rb
+- lib/end_of_life/version_detectors.rb
+- lib/end_of_life/version_detectors/rails.rb
+- lib/end_of_life/version_detectors/ruby.rb
 homepage: https://github.com/MatheusRich/end_of_life
 licenses:
 - MIT
@@ -148,7 +176,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.2
+rubygems_version: 3.7.1
 specification_version: 4
-summary: Lists repositories using end-of-life Ruby versions.
+summary: Lists repositories using end-of-life software
 test_files: []

data/.standard.yml

@@ -1 +0,0 @@
-ruby_version: 2.7.1

data/lib/end_of_life/ruby_version/parser.rb

@@ -1,88 +0,0 @@
-require "bundler"
-require "tempfile"
-
-module EndOfLife
-  class RubyVersion
-    module Parser
-      extend self
-
-      def parse_file(file_name:, content:)
-        if file_name == ".ruby-version"
-          parse_ruby_version_file(content)
-        elsif file_name == "Gemfile.lock"
-          parse_gemfile_lock_file(content)
-        elsif file_name == "Gemfile"
-          parse_gemfile_file(content)
-        elsif file_name == ".tool-versions"
-          parse_tool_versions_file(content)
-        else
-          raise ArgumentError, "Unsupported file #{file_name}"
-        end
-      end
-
-      private
-
-      def parse_ruby_version_file(file_content)
-        string_version = file_content.strip.delete_prefix("ruby-")
-
-        RubyVersion.new(string_version)
-      end
-
-      def parse_gemfile_lock_file(file_content)
-        with_silent_bundler do
-          gemfile_lock_version = Bundler::LockfileParser.new(file_content).ruby_version
-          return if gemfile_lock_version.nil?
-
-          RubyVersion.new(gemfile_lock_version.delete_prefix("ruby "))
-        end
-      end
-
-      def parse_gemfile_file(file_content)
-        return if file_content.empty?
-
-        with_temp_gemfile(file_content) do |temp_gemfile|
-          gemfile_version = temp_gemfile.ruby_version&.gem_version
-          return nil if gemfile_version.nil?
-
-          RubyVersion.new(gemfile_version)
-        end
-      end
-
-      def parse_tool_versions_file(file_content)
-        file_content
-          .split("\n")
-          .filter_map do |line|
-            tool, version = line.strip.split
-
-            tool == "ruby" && RubyVersion.new(version)
-          end
-          .first
-      end
-
-      def with_silent_bundler
-        previous_ui = Bundler.ui
-        Bundler.ui = Bundler::UI::Silent.new
-
-        yield
-      ensure
-        Bundler.ui = previous_ui
-      end
-
-      def with_temp_gemfile(contents)
-        # Bundler requires a file to parse, so we need to create a temporary file
-        Tempfile.create("tempGemfile") do |tempfile|
-          tempfile.write(contents)
-          tempfile.rewind
-          gemfile = with_silent_bundler do
-            # This is security problem, since it runs the code inside the file
-            Bundler::Definition.build(tempfile.path, nil, {})
-          end
-
-          yield(gemfile)
-        rescue Bundler::BundlerError
-          nil
-        end
-      end
-    end
-  end
-end