docopslab-dev 0.1.0

data/lib/docopslab/dev/config_manager.rb

@@ -0,0 +1,241 @@
+# frozen_string_literal: true
+
+module DocOpsLab
+  module Dev
+    module ConfigManager
+      class << self
+        def generate_vale_config _context, style_override: nil
+          base_config = File.join(CONFIG_VENDOR_DIR, 'vale.ini')
+          project_config = '.config/vale.local.ini'
+          generated_config = CONFIG_PATHS[:vale]
+
+          return false unless File.exist?(base_config)
+
+          merged_content = if File.exist?(project_config)
+                             merge_ini_configs(base_config, project_config)
+                           else
+                             File.read(base_config)
+                           end
+
+          # Apply runtime style override if specified
+          merged_content = apply_vale_style_override(merged_content, style_override) if style_override
+
+          # Write generated config
+          if !File.exist?(generated_config) || File.read(generated_config) != merged_content
+            File.write(generated_config, merged_content)
+            override_msg = style_override ? " (#{style_override} styles)" : ''
+            puts "  📝 Generated #{generated_config} from base#{if File.exist?(project_config)
+                                                                 ' + local'
+                                                               end}#{override_msg}"
+            true
+          else
+            false
+          end
+        end
+
+        def generate_htmlproofer_config _context
+          base_config = File.join(CONFIG_VENDOR_DIR, 'htmlproofer.yml')
+          project_config = '.config/htmlproofer.local.yml'
+          generated_config = CONFIG_PATHS[:htmlproofer]
+
+          return false unless File.exist?(base_config)
+
+          merged_content = if File.exist?(project_config)
+                             merge_yaml_configs(base_config, project_config)
+                           else
+                             File.read(base_config)
+                           end
+
+          if !File.exist?(generated_config) || File.read(generated_config) != merged_content
+            File.write(generated_config, merged_content)
+            puts "  📝 Generated #{generated_config} from base#{' + local' if File.exist?(project_config)}"
+            true
+          else
+            false
+          end
+        end
+
+        def load_htmlproofer_config config_path=nil, policy: 'merge'
+          config_paths = if config_path && File.exist?(config_path)
+                           [config_path]
+                         else
+                           [CONFIG_PATHS[:htmlproofer]]
+                         end
+          config_paths << File.join(CONFIG_VENDOR_DIR, 'htmlproofer.yml') unless policy == 'replace'
+          config_path = config_paths.find { |path| File.exist?(path) }
+
+          return unless config_path
+
+          puts "📋 Using HTMLProofer config: #{config_path}"
+          begin
+            config = YAML.load_file(config_path)
+            # Convert string patterns to regex for ignore_urls and ignore_files
+            process_htmlproofer_patterns(config)
+          rescue StandardError => e
+            puts "⚠️  Failed to load #{config_path}: #{e.message}"
+          end
+        end
+
+        def process_htmlproofer_patterns config
+          # Convert string patterns to regex for ignore_urls
+          if config['ignore_urls'].is_a?(Array)
+            config['ignore_urls'] = config['ignore_urls'].map do |pattern|
+              if pattern.is_a?(String) && pattern.start_with?('/') && pattern.end_with?('/')
+                Regexp.new(pattern[1..-2])
+              else
+                pattern
+              end
+            end
+          end
+
+          # Convert string patterns to regex for ignore_files
+          if config['ignore_files'].is_a?(Array)
+            config['ignore_files'] = config['ignore_files'].map do |pattern|
+              pattern.is_a?(String) ? Regexp.new(pattern) : pattern
+            end
+          end
+
+          # Convert string keys to symbols for HTMLProofer
+          config.transform_keys(&:to_sym)
+        end
+
+        def merge_yaml_configs base_path, local_path
+          # Implement RuboCop-style inheritance for YAML files
+          require 'yaml'
+
+          base_config = YAML.load_file(base_path) || {}
+          project_config = YAML.load_file(local_path) || {}
+
+          # Merge with RuboCop semantics
+          merged_config = deep_merge_configs(base_config, project_config)
+
+          # Convert back to YAML
+          YAML.dump(merged_config)
+        end
+
+        def deep_merge_configs base, local
+          return local if base.nil?
+          return base if local.nil?
+
+          case local
+          when Hash
+            result = base.is_a?(Hash) ? base.dup : {}
+            local.each do |key, value|
+              if value.nil? # YAML null (~) cancels the setting
+                result.delete(key)
+              else
+                result[key] = deep_merge_configs(result[key], value)
+              end
+            end
+            result
+          else
+            # Non-hash values: local completely overrides base (including arrays)
+            local
+          end
+        end
+
+        def generate_simple_ini config
+          lines = []
+
+          # Global section first
+          if config['global'] && !config['global'].empty?
+            config['global'].each do |key, value|
+              lines << "#{key} = #{value}"
+            end
+            lines << ''
+          end
+
+          # Other sections
+          config.each do |section_name, section_data|
+            next if section_name == 'global'
+            next if section_data.empty?
+
+            lines << "[#{section_name}]"
+            section_data.each do |key, value|
+              lines << "#{key} = #{value}"
+            end
+            lines << ''
+          end
+
+          "#{lines.join("\n").strip}\n"
+        end
+
+        def get_path_config tool_slug, context
+          tool_meta = context.get_tool_metadata(tool_slug)
+          default_config = tool_meta&.dig('paths') || {}
+
+          manifest = context.load_manifest
+          project_config = manifest&.dig('tools')&.find { |t| t['tool'] == tool_slug }&.dig('paths') || {}
+
+          git_tracked_only = if project_config.key?('git_tracked_only')
+                               project_config['git_tracked_only']
+                             else
+                               default_config.fetch('git_tracked_only', true)
+                             end
+
+          # Project-level 'lint'/'skip' overrides gem-level 'patterns'/'ignored_paths'
+          lint_paths = project_config['lint'] || default_config['patterns']
+          skip_paths = (project_config['skip'] || []) + (default_config['ignored_paths'] || [])
+
+          {
+            lint: lint_paths,
+            skip: skip_paths.uniq,
+            exts: project_config['exts'] || default_config['exts'],
+            git_tracked_only: git_tracked_only
+          }
+        end
+
+        def merge_ini_configs base_path, local_path
+          # Simple but working INI merger; good enough for our needs
+          base_config = parse_simple_ini(File.read(base_path))
+          project_config = parse_simple_ini(File.read(local_path))
+
+          # Merge with RuboCop semantics: local overrides base, sections merge
+          merged_config = deep_merge_configs(base_config, project_config)
+
+          # Convert back to INI format
+          generate_simple_ini(merged_config)
+        end
+
+        def parse_simple_ini content
+          config = { 'global' => {} }
+          current_section = 'global'
+
+          content.lines.each do |line|
+            line = line.strip
+            next if line.empty? || line.start_with?('#')
+
+            if line =~ /^\[(.+)\]$/
+              current_section = ::Regexp.last_match(1)
+              config[current_section] = {}
+            elsif line =~ /^([^=]+)\s*=\s*(.*)$/
+              key = ::Regexp.last_match(1).strip
+              value = ::Regexp.last_match(2).strip
+              config[current_section][key] = value
+            end
+          end
+
+          config
+        end
+
+        def apply_vale_style_override content, override_type
+          # Parse the INI content
+          config = parse_simple_ini(content)
+
+          # Apply the override to the [*.adoc] section
+          if config['*.adoc']
+            case override_type
+            when :text
+              config['*.adoc']['BasedOnStyles'] = 'RedHat, DocOpsLab-Authoring'
+            when :adoc
+              config['*.adoc']['BasedOnStyles'] = 'AsciiDoc, DocOpsLab-AsciiDoc'
+            end
+          end
+
+          # Convert back to INI format
+          generate_simple_ini(config)
+        end
+      end
+    end
+  end
+end

data/lib/docopslab/dev/file_utils.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+require 'pathname'
+
+module DocOpsLab
+  module Dev
+    module FileUtilities
+      class << self
+        def find_shell_scripts context
+          # First, try to find files using the new path configuration system
+          files = find_files_to_lint('shellcheck', context)
+          return files if files && !files.empty?
+
+          # Fallback to old method if no paths are configured for shellcheck
+          scripts = []
+          patterns = [
+            '**/*.sh',
+            '**/*.bash',
+            '**/.*rc',
+            '**/.*profile',
+            'scripts/*.sh'
+          ]
+          patterns.each do |pattern|
+            Dir.glob(pattern).each do |file|
+              next unless File.file?(file)
+              next if file.include?('/.vendor/')
+              next if file.include?('/node_modules/')
+              next unless FileUtilities.git_tracked_or_staged?(file)
+
+              scripts << file if File.executable?(file) || FileUtilities.shell_shebang?(file)
+            end
+          end
+          scripts.uniq.sort
+        end
+
+        def shell_shebang? file
+          return false unless File.readable?(file)
+
+          first_line = File.open(file, 'r') do |f|
+            f.readline
+          rescue StandardError
+            ''
+          end
+          first_line.start_with?('#!') &&
+            (first_line.include?('sh') || first_line.include?('bash'))
+        end
+
+        def find_files_to_lint tool_slug, context
+          path_config = context.get_path_config(tool_slug)
+          lint_paths = path_config[:lint]
+          skip_paths = path_config[:skip]
+          exts = path_config[:exts]
+          git_tracked_only = path_config[:git_tracked_only]
+
+          return [] unless lint_paths
+
+          files = []
+          lint_paths.each do |path|
+            # If path is a directory, search recursively. Otherwise, it's a glob.
+            glob_pattern = File.directory?(path) ? File.join(path, '**', '*') : path
+            Dir.glob(glob_pattern).each do |file|
+              next unless File.file?(file)
+
+              # Normalize path by removing ./ prefix for consistent pattern matching
+              normalized = file.sub(%r{^\./}, '')
+              files << normalized
+            end
+          end
+
+          files.uniq!
+
+          # Filter by extension if exts is provided
+          if exts && !exts.empty?
+            files.select! do |file|
+              ext = File.extname(file).delete_prefix('.')
+              exts.include?(ext)
+            end
+          end
+
+          # Filter out ignored paths
+          files.reject! do |file|
+            should_skip = skip_paths.any? do |ignored|
+              FileUtilities.file_matches_ignore_pattern?(file, ignored)
+            end
+            should_skip
+          end
+
+          # Filter by git tracking status
+          if git_tracked_only
+            files.select! do |file|
+              is_tracked = FileUtilities.git_tracked_or_staged?(file)
+              is_tracked
+            end
+          end
+
+          files.sort
+        end
+
+        def find_asciidoc_files context
+          FileUtilities.find_files_to_lint('vale', context)
+        end
+
+        def file_matches_ignore_pattern? file, pattern
+          if pattern.include?('*') || pattern.include?('?')
+            # Handle glob patterns
+            # If pattern ends with /*, treat it as recursive (dir/**/*)
+            recursive_pattern = if pattern.end_with?('/*')
+                                  pattern.sub(%r{/\*$}, '/**/*')
+                                else
+                                  pattern
+                                end
+
+            File.fnmatch(recursive_pattern, file, File::FNM_PATHNAME | File::FNM_DOTMATCH) ||
+              # Also try exact match without modification for explicit patterns
+              File.fnmatch(pattern, file, File::FNM_PATHNAME | File::FNM_DOTMATCH)
+          else
+            # Non-glob patterns: match directory name anywhere in path
+            File.fnmatch("**/#{pattern}/**", file, File::FNM_PATHNAME | File::FNM_DOTMATCH) ||
+              File.fnmatch("**/#{pattern}", file, File::FNM_PATHNAME | File::FNM_DOTMATCH)
+          end
+        end
+
+        def git_tracked_or_staged? file
+          return true unless Dir.exist?('.git')
+
+          repo_root = `git rev-parse --show-toplevel`.strip
+          rel = Pathname.new(file).expand_path.relative_path_from(Pathname.new(repo_root)).to_s
+
+          # Check if the file is tracked
+          return true if system('git', 'ls-files', '--error-unmatch', rel, out: File::NULL, err: File::NULL)
+
+          # Check if the file is staged (but not necessarily committed yet)
+          return true if system('git', 'diff', '--name-only', '--cached', '--', rel, out: File::NULL, err: File::NULL)
+
+          false
+        end
+      end
+    end
+  end
+end

data/lib/docopslab/dev/git_hooks.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+
+module DocOpsLab
+  module Dev
+    module GitHooks
+      class << self
+        def install_missing_hooks
+          return unless Dir.exist?(hooks_dir)
+
+          Dir.glob("#{hooks_template_dir}/*.sh").each do |template_path|
+            hook_name = File.basename(template_path, '.sh')
+            hook_path = File.join(hooks_dir, hook_name)
+
+            next if File.exist?(hook_path)
+
+            puts "🪝 Installing #{hook_name} hook..."
+            FileUtils.cp(template_path, hook_path)
+            File.chmod(0o755, hook_path)
+            puts "✅ #{hook_name} hook installed"
+          end
+        end
+
+        def check_hook_updates
+          return puts 'ℹ️  No .git directory found' unless Dir.exist?(hooks_dir)
+
+          updates_available = false
+
+          Dir.glob("#{hooks_template_dir}/*.sh").each do |template_path|
+            hook_name = File.basename(template_path, '.sh')
+            hook_path = File.join(hooks_dir, hook_name)
+
+            if File.exist?(hook_path)
+              template_content = File.read(template_path)
+              current_content = File.read(hook_path)
+
+              if template_content != current_content
+                puts "🔄 Update available for #{hook_name} hook"
+                updates_available = true
+              end
+            else
+              puts "➕ New hook template available: #{hook_name}"
+              updates_available = true
+            end
+          end
+
+          if updates_available
+            puts "Run 'rake labdev:sync:hooks' to update hooks interactively"
+          else
+            puts '✅ All hooks are up to date'
+          end
+        end
+
+        def update_hooks_interactive
+          return puts 'ℹ️  No .git directory found' unless Dir.exist?(hooks_dir)
+
+          Dir.glob("#{hooks_template_dir}/*.sh").each do |template_path|
+            hook_name = File.basename(template_path, '.sh')
+            hook_path = File.join(hooks_dir, hook_name)
+
+            if File.exist?(hook_path)
+              template_content = File.read(template_path)
+              current_content = File.read(hook_path)
+
+              next if template_content == current_content
+
+              puts "🔄 #{hook_name} hook has updates available"
+              puts "Current file exists at: #{hook_path}"
+
+              print "Update #{hook_name} hook? [y/N]: "
+              response = $stdin.gets.chomp.downcase
+
+              if %w[y yes].include?(response)
+                File.write(hook_path, template_content)
+                File.chmod(0o755, hook_path)
+                puts "✅ #{hook_name} hook updated"
+              else
+                puts "⏭️  Skipped #{hook_name} hook"
+              end
+            else
+              puts "➕ New hook template: #{hook_name}"
+              print "Install #{hook_name} hook? [Y/n]: "
+              response = $stdin.gets.chomp.downcase
+
+              if response != 'n' && response != 'no'
+                FileUtils.cp(template_path, hook_path)
+                File.chmod(0o755, hook_path)
+                puts "✅ #{hook_name} hook installed"
+              else
+                puts "⏭️  Skipped #{hook_name} hook"
+              end
+            end
+          end
+        end
+
+        def list_hook_templates
+          puts '📋 Available git hook templates:'
+          puts ''
+
+          Dir.glob("#{hooks_template_dir}/*.sh").each do |template_path|
+            hook_name = File.basename(template_path, '.sh')
+            hook_path = File.join(hooks_dir, hook_name)
+
+            status = nil
+            if File.exist?(hook_path)
+              template_content = File.read(template_path)
+              current_content = File.read(hook_path)
+              status = template_content == current_content ? '✅ installed' : '🔄 update available'
+            else
+              status = '➕ not installed'
+            end
+
+            description = case hook_name
+                          when 'pre-commit'
+                            'Advisory checks & syntax validation (non-blocking)'
+                          when 'pre-push'
+                            'Comprehensive linting & quality gate (blocking)'
+                          else
+                            ''
+                          end
+
+            puts "  #{hook_name}: #{status}"
+            puts "    #{description}" unless description.empty?
+          end
+        end
+
+        private
+
+        def hooks_template_dir
+          HOOKS_SOURCE_DIR
+        end
+
+        def hooks_dir
+          HOOKS_DIR
+        end
+      end
+    end
+  end
+end

data/lib/docopslab/dev/help.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'yaml'
+
+module DocOpsLab
+  module Dev
+    module Help
+      class << self
+        def show_task_help task_string=nil
+          tasks_def_path = File.join(GEM_ROOT, 'specs/data/tasks-def.yml')
+
+          unless File.exist?(tasks_def_path)
+            puts '❌ Tasks definition file not found'
+            return
+          end
+
+          tasks_def = YAML.load_file(tasks_def_path)
+
+          if task_string.nil?
+            show_general_help
+            return
+          end
+
+          # Normalize task string (allow with or without labdev: prefix)
+          task_string = "labdev:#{task_string}" unless task_string.start_with?('labdev:')
+
+          # Parse task path
+          task_parts = task_string.sub('labdev:', '').split(':')
+
+          # Navigate to task in YAML structure
+          current = tasks_def['labdev']
+          found = true
+          task_parts.each do |part|
+            if current.is_a?(Hash) && current[part]
+              current = current[part]
+            else
+              puts "❌ Task not found: #{task_string}"
+              found = false
+              break
+            end
+          end
+
+          return unless found
+
+          show_task_details(task_string, current)
+        end
+
+        private
+
+        def show_general_help
+          puts '📚 DocOps Lab Development Tools - Available Tasks'
+          puts '=' * 60
+          puts ''
+          puts 'Use `bundle exec rake -T | grep labdev:` to see all tasks.'
+          puts 'Use `bundle exec rake labdev:help[verb:subtask]` for detailed help.'
+          puts ''
+          puts "Example: bundle exec rake 'labdev:help[run:script]'"
+          puts ''
+        end
+
+        def show_task_details task_string, task_info
+          puts "📚 Help for: #{task_string}"
+          puts '=' * 60
+          puts ''
+
+          if task_info['_desc']
+            puts "Description: #{task_info['_desc']}"
+            puts ''
+          end
+
+          if task_info['_docs']
+            puts 'Documentation:'
+            puts task_info['_docs']
+            puts ''
+          end
+
+          if task_info['_alias']
+            puts "⚠️  This is an alias for: #{task_info['_alias']}"
+            # Display help for the aliased task
+            show_task_help(task_info['_alias'])
+            return
+          end
+
+          # Show subtasks if this is a namespace
+          subtasks = task_info.select { |k, v| !k.start_with?('_') && v.is_a?(Hash) }
+          if subtasks.any?
+            puts 'Available subtasks:'
+            puts ''
+            subtasks.each do |subtask_name, subtask_info|
+              desc = subtask_info['_desc'] || '(no description)'
+              alias_note = subtask_info['_alias'] ? " → #{subtask_info['_alias']}" : ''
+              puts "  #{task_string}:#{subtask_name}#{alias_note}"
+              puts "    #{desc}"
+              puts ''
+            end
+          end
+
+          if task_info['_args']
+            puts 'Arguments:'
+            task_info['_args'].each do |arg_name, arg_info|
+              required = arg_info['required'] ? '(required)' : '(optional)'
+              puts "  #{arg_name} #{required}"
+              puts "    #{arg_info['summ']}" if arg_info['summ']
+              puts "    #{arg_info['docs'].strip.split("\n").join("\n    ")}" if arg_info['docs']
+              puts ''
+            end
+          end
+
+          return unless task_info['_test']
+
+          puts 'Example usage:'
+          task_info['_test'].each do |test_cmd|
+            puts "  #{test_cmd}"
+          end
+          puts ''
+        end
+      end
+    end
+  end
+end