stackharbinger 0.2.0 → 0.4.0

data/lib/harbinger/analyzers/mongo_detector.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+require_relative "docker_compose_detector"
+
+module Harbinger
+  module Analyzers
+    # Detects MongoDB version from projects
+    class MongoDetector
+      attr_reader :project_path
+
+      def initialize(project_path)
+        @project_path = project_path
+      end
+
+      # Main detection method - returns version string or nil
+      def detect
+        return nil unless mongo_detected?
+
+        # Try docker-compose.yml first
+        version = detect_from_docker_compose
+        return version if version
+
+        # Try shell command
+        version = detect_from_shell
+        return version if version
+
+        # Fallback to gem version
+        detect_from_gemfile_lock
+      end
+
+      # Check if MongoDB is used in this project
+      def mongo_detected?
+        gemfile_has_mongo? || docker_compose_has_mongo?
+      end
+
+      private
+
+      def detect_from_docker_compose
+        docker = DockerComposeDetector.new(project_path)
+        docker.image_version("mongo")
+      end
+
+      def detect_from_shell
+        # Try mongosh first (modern shell, MongoDB 5+)
+        output = `mongosh --version 2>&1`.strip
+        return output if $CHILD_STATUS.success? && output.match?(/^\d+\.\d+/)
+
+        # Try legacy mongo shell
+        output = `mongo --version 2>&1`.strip
+        if $CHILD_STATUS.success?
+          match = output.match(/MongoDB shell version v?(\d+\.\d+(?:\.\d+)?)/)
+          return match[1] if match
+        end
+
+        # Fall back to mongod (server)
+        output = `mongod --version 2>&1`.strip
+        return nil unless $CHILD_STATUS.success?
+
+        match = output.match(/db version v(\d+\.\d+(?:\.\d+)?)/)
+        match[1] if match
+      rescue StandardError
+        nil
+      end
+
+      def detect_from_gemfile_lock
+        content = read_gemfile_lock
+        return nil unless content
+
+        # Look for mongoid gem version first (most common for Rails)
+        match = content.match(/^\s{4}mongoid\s+\(([^)]+)\)/)
+        return "#{match[1]} (mongoid gem)" if match
+
+        # Fall back to mongo gem
+        match = content.match(/^\s{4}mongo\s+\(([^)]+)\)/)
+        return "#{match[1]} (mongo gem)" if match
+
+        nil
+      end
+
+      def gemfile_has_mongo?
+        content = read_gemfile_lock
+        return false unless content
+
+        content.include?("mongoid (") || content.include?("mongo (")
+      end
+
+      def docker_compose_has_mongo?
+        docker = DockerComposeDetector.new(project_path)
+        return false unless docker.docker_compose_exists?
+
+        docker.image_version("mongo") != nil
+      end
+
+      def read_gemfile_lock
+        path = File.join(project_path, "Gemfile.lock")
+        return nil unless File.exist?(path)
+
+        File.read(path)
+      rescue StandardError
+        nil
+      end
+    end
+  end
+end

data/lib/harbinger/analyzers/mysql_detector.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require_relative "database_detector"
+require_relative "docker_compose_detector"
+
+module Harbinger
+  module Analyzers
+    # Detects MySQL version from Rails projects
+    # Supports both mysql2 and trilogy adapters
+    class MysqlDetector < DatabaseDetector
+      protected
+
+      def adapter_name
+        %w[mysql2 trilogy]
+      end
+
+      def detect_from_docker_compose
+        docker = DockerComposeDetector.new(project_path)
+        # Try mysql first, then mariadb
+        docker.image_version("mysql") || docker.image_version("mariadb")
+      end
+
+      def detect_from_shell
+        # Skip shell command if database is remote
+        return nil if remote_database?
+
+        # Try mysql command first, then mysqld
+        output = execute_command("mysql --version") || execute_command("mysqld --version")
+        return nil unless output
+
+        # Parse: "mysql  Ver 8.0.33" or "mysqld  Ver 8.0.33"
+        # Also handles MariaDB: "mysql  Ver 15.1 Distrib 10.11.2-MariaDB"
+        match = output.match(/Ver\s+(?:\d+\.\d+\s+Distrib\s+)?(\d+\.\d+\.\d+)/)
+        match[1] if match
+      end
+
+      def detect_from_gemfile_lock
+        content = parse_gemfile_lock
+        return nil unless content
+
+        # Check which adapter is being used
+        config = parse_database_yml
+        return nil unless config
+
+        section = config["production"] || config["default"] || config[config.keys.first]
+        return nil unless section
+
+        adapter = extract_adapter_from_section(section)
+
+        # Return appropriate gem version based on adapter
+        if adapter == "trilogy"
+          version = extract_gem_version(content, "trilogy")
+          version ? "#{version} (trilogy gem)" : nil
+        else
+          version = extract_gem_version(content, "mysql2")
+          version ? "#{version} (mysql2 gem)" : nil
+        end
+      end
+
+      private
+
+      # Check if database configuration indicates a remote database
+      # (same logic as PostgresDetector)
+      def remote_database?
+        config = parse_database_yml
+        return false unless config
+
+        section = config["production"] || config["default"] || config[config.keys.first]
+        return false unless section
+
+        db_config = if section["adapter"]
+                      section
+                    else
+                      section["primary"] || section.values.find { |v| v.is_a?(Hash) && v["adapter"] }
+                    end
+
+        return false unless db_config
+
+        host = db_config["host"]
+
+        # No host specified = localhost (Unix socket)
+        return false if host.nil? || host.empty?
+
+        # Explicit localhost indicators
+        local_hosts = ["localhost", "127.0.0.1", "::1", "0.0.0.0"]
+        !local_hosts.include?(host.to_s.downcase)
+      end
+    end
+  end
+end

data/lib/harbinger/analyzers/postgres_detector.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require_relative "database_detector"
+require_relative "docker_compose_detector"
+
+module Harbinger
+  module Analyzers
+    # Detects PostgreSQL version from Rails projects
+    class PostgresDetector < DatabaseDetector
+      protected
+
+      def adapter_name
+        "postgresql"
+      end
+
+      def detect_from_docker_compose
+        docker = DockerComposeDetector.new(project_path)
+        docker.image_version("postgres")
+      end
+
+      def detect_from_shell
+        # Skip shell command if database is remote
+        # (shell gives client version, not server version)
+        return nil if remote_database?
+
+        output = execute_command("psql --version")
+        return nil unless output
+
+        # Parse: "psql (PostgreSQL) 15.3" or "psql (PostgreSQL) 15.3 (Ubuntu 15.3-1)"
+        match = output.match(/PostgreSQL\)\s+(\d+\.\d+)/)
+        match[1] if match
+      end
+
+      def detect_from_gemfile_lock
+        content = parse_gemfile_lock
+        version = extract_gem_version(content, "pg")
+        version ? "#{version} (pg gem)" : nil
+      end
+
+      private
+
+      # Check if database configuration indicates a remote database
+      def remote_database?
+        config = parse_database_yml
+        return false unless config
+
+        # Get the section with database config
+        section = config["production"] || config["default"] || config[config.keys.first]
+        return false unless section
+
+        # Handle multi-database config
+        db_config = if section["adapter"]
+                      section
+                    else
+                      section["primary"] || section.values.find { |v| v.is_a?(Hash) && v["adapter"] }
+                    end
+
+        return false unless db_config
+
+        host = db_config["host"]
+
+        # No host specified = localhost (Unix socket)
+        return false if host.nil? || host.empty?
+
+        # Explicit localhost indicators
+        local_hosts = ["localhost", "127.0.0.1", "::1", "0.0.0.0"]
+        !local_hosts.include?(host.to_s.downcase)
+      end
+    end
+  end
+end

data/lib/harbinger/analyzers/redis_detector.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require_relative "docker_compose_detector"
+
+module Harbinger
+  module Analyzers
+    # Detects Redis version from projects
+    class RedisDetector
+      attr_reader :project_path
+
+      def initialize(project_path)
+        @project_path = project_path
+      end
+
+      # Main detection method - returns version string or nil
+      def detect
+        return nil unless redis_detected?
+
+        # Try docker-compose.yml first
+        version = detect_from_docker_compose
+        return version if version
+
+        # Try shell command
+        version = detect_from_shell
+        return version if version
+
+        # Fallback to gem version
+        detect_from_gemfile_lock
+      end
+
+      # Check if Redis is used in this project
+      def redis_detected?
+        gemfile_has_redis? || docker_compose_has_redis?
+      end
+
+      private
+
+      def detect_from_docker_compose
+        docker = DockerComposeDetector.new(project_path)
+        docker.image_version("redis")
+      end
+
+      def detect_from_shell
+        # Try redis-cli first (more commonly available)
+        output = `redis-cli -v 2>&1`.strip
+        if $CHILD_STATUS.success?
+          # Parse: "redis-cli 7.0.5"
+          match = output.match(/redis-cli\s+(\d+\.\d+(?:\.\d+)?)/)
+          return match[1] if match
+        end
+
+        # Fall back to redis-server
+        output = `redis-server --version 2>&1`.strip
+        return nil unless $CHILD_STATUS.success?
+
+        # Parse: "Redis server v=7.2.4 sha=..."
+        match = output.match(/v=(\d+\.\d+(?:\.\d+)?)/)
+        match[1] if match
+      rescue StandardError
+        nil
+      end
+
+      def detect_from_gemfile_lock
+        content = read_gemfile_lock
+        return nil unless content
+
+        # Look for redis gem version
+        match = content.match(/^\s{4}redis\s+\(([^)]+)\)/)
+        return "#{match[1]} (gem)" if match
+
+        nil
+      end
+
+      def gemfile_has_redis?
+        content = read_gemfile_lock
+        return false unless content
+
+        content.include?("redis (")
+      end
+
+      def docker_compose_has_redis?
+        docker = DockerComposeDetector.new(project_path)
+        return false unless docker.docker_compose_exists?
+
+        docker.image_version("redis") != nil
+      end
+
+      def read_gemfile_lock
+        path = File.join(project_path, "Gemfile.lock")
+        return nil unless File.exist?(path)
+
+        File.read(path)
+      rescue StandardError
+        nil
+      end
+    end
+  end
+end

data/lib/harbinger/analyzers/ruby_detector.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "docker_compose_detector"
+
 module Harbinger
   module Analyzers
     class RubyDetector
@@ -10,7 +12,8 @@ module Harbinger
       def detect
         detect_from_ruby_version ||
           detect_from_gemfile ||
-          detect_from_gemfile_lock
+          detect_from_gemfile_lock ||
+          detect_from_dockerfile
       end
 
       def ruby_detected?
@@ -61,6 +64,11 @@ module Harbinger
         # Remove patch level suffix (e.g., "p223")
         version.sub(/p\d+$/, "")
       end
+
+      def detect_from_dockerfile
+        docker = DockerComposeDetector.new(project_path)
+        docker.ruby_version_from_dockerfile
+      end
     end
   end
 end