vagrant-ssh-config-manager 0.8.3 → 1.0.0.alpha

data/lib/{vagrant-ssh-config-manager → vagrant_ssh_config_manager}/file_manager.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'fileutils'
 require 'digest'
 require 'tempfile'
@@ -9,7 +11,7 @@ module VagrantPlugins
       # Initialize FileManager with configuration
       def initialize(config)
         @config = config
-        @logger = Log4r::Logger.new("vagrant::plugins::sshconfigmanager::filemanager")
+        @logger = Log4r::Logger.new('vagrant::plugins::sshconfigmanager::filemanager')
       end
 
       # Generate unique filename for VM SSH config
@@ -20,10 +22,14 @@ module VagrantPlugins
         "#{project_hash}-#{vm_name}.conf"
       end
 
-      # Get full path for VM SSH config file
-      def get_file_path(machine)
-        filename = generate_filename(machine)
-        File.join(@config.ssh_config_dir, filename)
+      # Generate full file path for a machine's SSH config under ssh_config_dir
+      def generate_file_path(machine)
+        File.join(@config.ssh_config_dir, generate_filename(machine))
+      end
+
+      # Return full path for a machine's SSH config file
+      def file_path(machine)
+        generate_file_path(machine)
       end
 
       # Generate SSH config content for a VM
@@ -32,28 +38,28 @@ module VagrantPlugins
         return nil unless ssh_info
 
         content = []
-        content << "# Managed by vagrant-ssh-config-manager plugin"
+        content << '# Managed by vagrant-ssh-config-manager plugin'
         content << "# Project: #{File.basename(machine.env.root_path)}"
         content << "# VM: #{machine.name}"
         content << "# Generated: #{Time.now.strftime('%Y-%m-%d %H:%M:%S')}"
-        content << ""
-        
+        content << ''
+
         host_name = generate_host_name(machine)
         content << "Host #{host_name}"
         content << "  HostName #{ssh_info[:host]}"
         content << "  Port #{ssh_info[:port]}"
         content << "  User #{ssh_info[:username]}"
-        
-        if ssh_info[:private_key_path] && ssh_info[:private_key_path].first
+
+        if ssh_info[:private_key_path]&.first
           content << "  IdentityFile #{ssh_info[:private_key_path].first}"
-          content << "  IdentitiesOnly yes"
+          content << '  IdentitiesOnly yes'
         end
-        
-        content << "  UserKnownHostsFile /dev/null"
-        content << "  StrictHostKeyChecking no"
-        content << "  PasswordAuthentication no"
-        content << "  LogLevel FATAL"
-        content << ""
+
+        content << '  UserKnownHostsFile /dev/null'
+        content << '  StrictHostKeyChecking no'
+        content << '  PasswordAuthentication no'
+        content << '  LogLevel FATAL'
+        content << ''
 
         content.join("\n")
       end
@@ -62,20 +68,20 @@ module VagrantPlugins
       def write_ssh_config_file(machine)
         return false unless @config.enabled
 
-        file_path = get_file_path(machine)
+        file_path = file_path(machine)
         content = generate_ssh_config_content(machine)
         return false unless content
 
         begin
           # Ensure directory exists
-          FileUtils.mkdir_p(File.dirname(file_path), mode: 0700)
-          
+          FileUtils.mkdir_p(File.dirname(file_path), mode: 0o700)
+
           # Use atomic write with temporary file
           write_file_atomically(file_path, content)
-          
+
           @logger.info("SSH config file created: #{file_path}")
           true
-        rescue => e
+        rescue StandardError => e
           @logger.error("Failed to write SSH config file #{file_path}: #{e.message}")
           false
         end
@@ -83,13 +89,13 @@ module VagrantPlugins
 
       # Remove SSH config file for VM
       def remove_ssh_config_file(machine)
-        file_path = get_file_path(machine)
-        
+        file_path = file_path(machine)
+
         begin
           if File.exist?(file_path)
             File.delete(file_path)
             @logger.info("SSH config file removed: #{file_path}")
-            
+
             # Clean up empty directory if configured
             cleanup_empty_directory if @config.cleanup_empty_dir
             true
@@ -97,7 +103,7 @@ module VagrantPlugins
             @logger.debug("SSH config file does not exist: #{file_path}")
             false
           end
-        rescue => e
+        rescue StandardError => e
           @logger.error("Failed to remove SSH config file #{file_path}: #{e.message}")
           false
         end
@@ -105,46 +111,49 @@ module VagrantPlugins
 
       # Check if SSH config file exists for VM
       def ssh_config_file_exists?(machine)
-        File.exist?(get_file_path(machine))
+        File.exist?(file_path(machine))
       end
 
       # Validate SSH config file content
-      def validate_ssh_config_content(content)
+      # Returns true if the content contains required SSH config elements
+      def validate_ssh_config_content?(content)
         return false if content.nil? || content.empty?
-        
+
         # Basic validation - check for required SSH config elements
-        content.include?("Host ") && content.include?("HostName ") && content.include?("Port ")
+        content.include?('Host ') && content.include?('HostName ') && content.include?('Port ')
       end
 
+      alias validate_ssh_config_content validate_ssh_config_content?
+
       # Detect and clean up orphaned SSH config files
       def cleanup_orphaned_files
         return unless Dir.exist?(@config.ssh_config_dir)
 
         orphaned_files = []
-        config_files = Dir.glob(File.join(@config.ssh_config_dir, "*.conf"))
+        config_files = Dir.glob(File.join(@config.ssh_config_dir, '*.conf'))
 
         config_files.each do |file_path|
-          filename = File.basename(file_path, ".conf")
-          
+          filename = File.basename(file_path, '.conf')
+
           # Parse filename to extract project hash and VM name
-          if filename.match(/^([a-f0-9]{8})-(.+)$/)
-            project_hash = $1
-            vm_name = $2
-            
-            # Check if this looks like an orphaned file
-            # (This is a basic heuristic - in practice, you might want more sophisticated detection)
-            file_age = Time.now - File.mtime(file_path)
-            
-            # Consider files older than 30 days as potentially orphaned
-            if file_age > (30 * 24 * 60 * 60) # 30 days in seconds
-              orphaned_files << {
-                path: file_path,
-                project_hash: project_hash,
-                vm_name: vm_name,
-                age_days: (file_age / (24 * 60 * 60)).round
-              }
-            end
-          end
+          next unless filename.match(/^([a-f0-9]{8})-(.+)$/)
+
+          project_hash = ::Regexp.last_match(1)
+          vm_name = ::Regexp.last_match(2)
+
+          # Check if this looks like an orphaned file
+          # (This is a basic heuristic - in practice, you might want more sophisticated detection)
+          file_age = Time.now - File.mtime(file_path)
+
+          # Consider files older than 30 days as potentially orphaned
+          next unless file_age > (30 * 24 * 60 * 60) # 30 days in seconds
+
+          orphaned_files << {
+            path: file_path,
+            project_hash: project_hash,
+            vm_name: vm_name,
+            age_days: (file_age / (24 * 60 * 60)).round
+          }
         end
 
         # Log detected orphaned files
@@ -164,27 +173,28 @@ module VagrantPlugins
         removed_count = 0
 
         orphaned_files.each do |file_info|
-          begin
-            File.delete(file_info[:path])
-            @logger.info("Removed orphaned SSH config file: #{file_info[:path]}")
-            removed_count += 1
-          rescue => e
-            @logger.error("Failed to remove orphaned file #{file_info[:path]}: #{e.message}")
-          end
+          File.delete(file_info[:path])
+          @logger.info("Removed orphaned SSH config file: #{file_info[:path]}")
+          removed_count += 1
+        rescue StandardError => e
+          @logger.error("Failed to remove orphaned file #{file_info[:path]}: #{e.message}")
         end
 
         # Clean up empty directory if configured
-        cleanup_empty_directory if @config.cleanup_empty_dir && removed_count > 0
+        cleanup_empty_directory if @config.cleanup_empty_dir && removed_count.positive?
 
         removed_count
       end
 
-      # Get all config files in the directory
-      def get_all_config_files
-        return [] unless Dir.exist?(@config.ssh_config_dir)
-        Dir.glob(File.join(@config.ssh_config_dir, "*.conf"))
+      # Return list of all config files
+      def all_config_files
+        Dir.glob(File.join(@config.ssh_config_dir, '*.conf'))
       end
 
+      # Backward compatibility aliases
+      alias get_file_path file_path
+      alias get_all_config_files all_config_files
+
       private
 
       # Generate unique project hash from root path
@@ -208,10 +218,10 @@ module VagrantPlugins
         begin
           temp_file.write(content)
           temp_file.close
-          
+
           # Set proper permissions before moving
-          File.chmod(0600, temp_file.path)
-          
+          File.chmod(0o600, temp_file.path)
+
           # Atomic move
           FileUtils.mv(temp_file.path, file_path)
         ensure
@@ -222,22 +232,22 @@ module VagrantPlugins
       # Clean up empty directory if no config files remain
       def cleanup_empty_directory
         return unless Dir.exist?(@config.ssh_config_dir)
-        
+
         entries = Dir.entries(@config.ssh_config_dir) - %w[. ..]
-        if entries.empty?
-          begin
-            # Remove Include directive before removing directory
-            if @config.manage_includes
-              require_relative 'include_manager'
-              include_manager = IncludeManager.new(@config)
-              include_manager.remove_include_directive
-            end
-            
-            Dir.rmdir(@config.ssh_config_dir)
-            @logger.info("Removed empty SSH config directory: #{@config.ssh_config_dir}")
-          rescue => e
-            @logger.error("Failed to remove empty directory #{@config.ssh_config_dir}: #{e.message}")
+        return unless entries.empty?
+
+        begin
+          # Remove Include directive before removing directory
+          if @config.manage_includes
+            require_relative 'include_manager'
+            include_manager = IncludeManager.new(@config)
+            include_manager.remove_include_directive
           end
+
+          Dir.rmdir(@config.ssh_config_dir)
+          @logger.info("Removed empty SSH config directory: #{@config.ssh_config_dir}")
+        rescue StandardError => e
+          @logger.error("Failed to remove empty directory #{@config.ssh_config_dir}: #{e.message}")
         end
       end
     end

data/lib/{vagrant-ssh-config-manager → vagrant_ssh_config_manager}/include_manager.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'fileutils'
 require 'tempfile'
 require 'log4r'
@@ -5,24 +7,24 @@ require 'log4r'
 module VagrantPlugins
   module SshConfigManager
     class IncludeManager
-      PLUGIN_MARKER_START = "# BEGIN vagrant-ssh-config-manager"
-      PLUGIN_MARKER_END = "# END vagrant-ssh-config-manager"
+      PLUGIN_MARKER_START = '# BEGIN vagrant-ssh-config-manager'
+      PLUGIN_MARKER_END = '# END vagrant-ssh-config-manager'
 
       # Initialize IncludeManager with configuration
       def initialize(config)
         @config = config
-        @logger = Log4r::Logger.new("vagrant::plugins::sshconfigmanager::includemanager")
+        @logger = Log4r::Logger.new('vagrant::plugins::sshconfigmanager::includemanager')
       end
 
       # Get the SSH config file path (always ~/.ssh/config)
       def ssh_config_file
-        @ssh_config_file ||= File.expand_path("~/.ssh/config")
+        @ssh_config_file ||= File.expand_path('~/.ssh/config')
       end
 
       # Check if Include directive exists in main SSH config
       def include_directive_exists?
         return false unless File.exist?(ssh_config_file)
-        
+
         content = File.read(ssh_config_file)
         include_pattern = /^Include\s+#{Regexp.escape(@config.ssh_config_dir)}/
         content.match?(include_pattern)
@@ -36,13 +38,13 @@ module VagrantPlugins
         begin
           # Create backup before modifying
           create_backup
-          
+
           # Add Include directive at the beginning of file
           add_include_to_config
-          
+
           @logger.info("Added Include directive for #{@config.ssh_config_dir} to ~/.ssh/config")
           true
-        rescue => e
+        rescue StandardError => e
           @logger.error("Failed to add Include directive: #{e.message}")
           restore_backup
           false
@@ -57,13 +59,13 @@ module VagrantPlugins
         begin
           # Create backup before modifying
           create_backup
-          
+
           # Remove Include directive
           remove_include_from_config
-          
+
           @logger.info("Removed Include directive for #{@config.ssh_config_dir} from ~/.ssh/config")
           true
-        rescue => e
+        rescue StandardError => e
           @logger.error("Failed to remove Include directive: #{e.message}")
           restore_backup
           false
@@ -74,7 +76,7 @@ module VagrantPlugins
       def should_remove_include_directive?
         return false unless @config.cleanup_empty_dir
         return false unless Dir.exist?(@config.ssh_config_dir)
-        
+
         # Check if directory is empty (excluding . and ..)
         entries = Dir.entries(@config.ssh_config_dir) - %w[. ..]
         config_files = entries.select { |file| file.end_with?('.conf') }
@@ -87,7 +89,9 @@ module VagrantPlugins
 
         if should_remove_include_directive?
           remove_include_directive
-        elsif Dir.exist?(@config.ssh_config_dir) && !Dir.entries(@config.ssh_config_dir).select { |f| f.end_with?('.conf') }.empty?
+        elsif Dir.exist?(@config.ssh_config_dir) && Dir.entries(@config.ssh_config_dir).any? do |f|
+          File.file?(File.join(@config.ssh_config_dir, f)) && f.end_with?('.conf')
+        end
           add_include_directive
         end
       end
@@ -95,10 +99,10 @@ module VagrantPlugins
       # Parse SSH config file and find optimal location for Include
       def find_include_location(content)
         lines = content.lines
-        
+
         # Look for existing Include directives to place ours with them
         include_line_index = lines.find_index { |line| line.strip.start_with?('Include ') }
-        
+
         if include_line_index
           # Place before other Include directives
           include_line_index
@@ -106,11 +110,9 @@ module VagrantPlugins
           # Place at the beginning of file, after any initial comments
           comment_end = 0
           lines.each_with_index do |line, index|
-            if line.strip.empty? || line.strip.start_with?('#')
-              comment_end = index + 1
-            else
-              break
-            end
+            break unless line.strip.empty? || line.strip.start_with?('#')
+
+            comment_end = index + 1
           end
           comment_end
         end
@@ -119,24 +121,25 @@ module VagrantPlugins
       # Check if main SSH config file is write-protected
       def main_config_writable?
         return false unless File.exist?(ssh_config_file)
+
         File.writable?(ssh_config_file)
       end
 
       # Handle edge case: empty main config file
       def handle_empty_main_config
-        unless File.exist?(ssh_config_file)
-          # Create empty SSH config file with proper permissions
-          FileUtils.mkdir_p(File.dirname(ssh_config_file), mode: 0700)
-          File.write(ssh_config_file, "")
-          File.chmod(0600, ssh_config_file)
-          @logger.info("Created empty SSH config file: #{ssh_config_file}")
-        end
+        return if File.exist?(ssh_config_file)
+
+        # Create empty SSH config file with proper permissions
+        FileUtils.mkdir_p(File.dirname(ssh_config_file), mode: 0o700)
+        File.write(ssh_config_file, '')
+        File.chmod(0o600, ssh_config_file)
+        @logger.info("Created empty SSH config file: #{ssh_config_file}")
       end
 
       # Validate SSH config file format
       def validate_main_config
         return true unless File.exist?(ssh_config_file)
-        
+
         begin
           content = File.read(ssh_config_file)
           # Basic validation - check for severely malformed config
@@ -144,14 +147,14 @@ module VagrantPlugins
           lines.each_with_index do |line, index|
             stripped = line.strip
             next if stripped.empty? || stripped.start_with?('#')
-            
+
             # Check for basic SSH config format issues
-            if stripped.include?("\t") && stripped.start_with?("Host ")
+            if stripped.include?("\t") && stripped.start_with?('Host ')
               @logger.warn("Potential SSH config format issue at line #{index + 1}: tabs in Host directive")
             end
           end
           true
-        rescue => e
+        rescue StandardError => e
           @logger.error("SSH config validation failed: #{e.message}")
           false
         end
@@ -168,23 +171,23 @@ module VagrantPlugins
 
       # Restore backup of main SSH config file
       def restore_backup
-        if @backup_path && File.exist?(@backup_path)
-          FileUtils.cp(@backup_path, ssh_config_file)
-          File.delete(@backup_path)
-          @logger.info("Restored SSH config from backup")
-        end
+        return unless @backup_path && File.exist?(@backup_path)
+
+        FileUtils.cp(@backup_path, ssh_config_file)
+        File.delete(@backup_path)
+        @logger.info('Restored SSH config from backup')
       end
 
       # Add Include directive to SSH config
       def add_include_to_config
         handle_empty_main_config
-        
-        content = File.exist?(ssh_config_file) ? File.read(ssh_config_file) : ""
+
+        content = File.exist?(ssh_config_file) ? File.read(ssh_config_file) : ''
         lines = content.lines
-        
+
         # Find optimal location for Include
         insert_index = find_include_location(content)
-        
+
         # Create Include directive with plugin markers
         include_lines = [
           "#{PLUGIN_MARKER_START}\n",
@@ -192,10 +195,10 @@ module VagrantPlugins
           "#{PLUGIN_MARKER_END}\n",
           "\n"
         ]
-        
+
         # Insert Include directive
         lines.insert(insert_index, *include_lines)
-        
+
         # Write back to file atomically
         write_config_atomically(lines.join)
       end
@@ -203,29 +206,27 @@ module VagrantPlugins
       # Remove Include directive from SSH config
       def remove_include_from_config
         return unless File.exist?(ssh_config_file)
-        
+
         content = File.read(ssh_config_file)
         lines = content.lines
-        
+
         # Find and remove plugin-managed Include directive
         start_index = lines.find_index { |line| line.strip == PLUGIN_MARKER_START.strip }
         end_index = lines.find_index { |line| line.strip == PLUGIN_MARKER_END.strip }
-        
+
         if start_index && end_index && end_index > start_index
           # Remove lines between markers (inclusive)
           lines.slice!(start_index..end_index)
-          
+
           # Remove trailing empty line if it exists
-          if lines[start_index] && lines[start_index].strip.empty?
-            lines.delete_at(start_index)
-          end
+          lines.delete_at(start_index) if lines[start_index] && lines[start_index].strip.empty?
         else
           # Fallback: remove any Include directive for our directory
           lines.reject! do |line|
             line.strip.match?(/^Include\s+#{Regexp.escape(@config.ssh_config_dir)}/)
           end
         end
-        
+
         # Write back to file atomically
         write_config_atomically(lines.join)
       end
@@ -236,10 +237,10 @@ module VagrantPlugins
         begin
           temp_file.write(content)
           temp_file.close
-          
+
           # Set proper permissions before moving
-          File.chmod(0600, temp_file.path)
-          
+          File.chmod(0o600, temp_file.path)
+
           # Atomic move
           FileUtils.mv(temp_file.path, ssh_config_file)
         ensure

data/lib/{vagrant-ssh-config-manager → vagrant_ssh_config_manager}/plugin.rb

@@ -1,54 +1,56 @@
-require "vagrant"
+# frozen_string_literal: true
+
+require 'vagrant'
 
 module VagrantPlugins
   module SshConfigManager
-    class Plugin < Vagrant.plugin("2")
-      name "SSH Config Manager"
+    class Plugin < Vagrant.plugin('2')
+      name 'SSH Config Manager'
       description <<-DESC
-      This plugin automatically manages SSH configurations by leveraging Vagrant's 
-      internal SSH knowledge. It creates and maintains SSH config entries when VMs 
+      This plugin automatically manages SSH configurations by leveraging Vagrant's#{' '}
+      internal SSH knowledge. It creates and maintains SSH config entries when VMs#{' '}
       are started and cleans them up when VMs are destroyed.
       DESC
 
       # Register the configuration class
       config :sshconfigmanager do
-        require "vagrant-ssh-config-manager/config"
+        require 'vagrant_ssh_config_manager/config'
         Config
       end
 
       # Hook into various Vagrant actions
       action_hook(:ssh_config_manager, :machine_action_up) do |hook|
-        require "vagrant-ssh-config-manager/action/up"
+        require 'vagrant_ssh_config_manager/action/up'
         hook.after(Vagrant::Action::Builtin::WaitForCommunicator, Action::Up)
       end
 
       action_hook(:ssh_config_manager, :machine_action_destroy) do |hook|
-        require "vagrant-ssh-config-manager/action/destroy"
+        require 'vagrant_ssh_config_manager/action/destroy'
         hook.before(Vagrant::Action::Builtin::DestroyConfirm, Action::Destroy)
       end
 
       action_hook(:ssh_config_manager, :machine_action_reload) do |hook|
-        require "vagrant-ssh-config-manager/action/reload"
+        require 'vagrant_ssh_config_manager/action/reload'
         hook.after(Vagrant::Action::Builtin::WaitForCommunicator, Action::Reload)
       end
 
       action_hook(:ssh_config_manager, :machine_action_halt) do |hook|
-        require "vagrant-ssh-config-manager/action/halt"
+        require 'vagrant_ssh_config_manager/action/halt'
         hook.before(Vagrant::Action::Builtin::GracefulHalt, Action::Halt)
       end
 
       action_hook(:ssh_config_manager, :machine_action_suspend) do |hook|
-        require "vagrant-ssh-config-manager/action/halt"
+        require 'vagrant_ssh_config_manager/action/halt'
         hook.before(Vagrant::Action::Builtin::Suspend, Action::Halt)
       end
 
       action_hook(:ssh_config_manager, :machine_action_resume) do |hook|
-        require "vagrant-ssh-config-manager/action/up"
+        require 'vagrant_ssh_config_manager/action/up'
         hook.after(Vagrant::Action::Builtin::Resume, Action::Up)
       end
 
       action_hook(:ssh_config_manager, :machine_action_provision) do |hook|
-        require "vagrant-ssh-config-manager/action/provision"
+        require 'vagrant_ssh_config_manager/action/provision'
         hook.after(Vagrant::Action::Builtin::Provision, Action::Provision)
       end
     end