solidstats 2.0.0 → 3.0.0.beta.1

data/app/controllers/solidstats/quality_controller.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+module Solidstats
+  class QualityController < ApplicationController
+    layout 'solidstats/dashboard'
+    
+    # Display Standard gem code quality analysis
+    def style_patrol
+      @analysis_data = Solidstats::StylePatrolService.collect_data
+      @summary = Solidstats::StylePatrolService.get_summary
+      
+      # Group issues by file for better display
+      if @analysis_data[:issues].present?
+        @issues_by_file = @analysis_data[:issues].group_by { |issue| issue[:file] }
+        @issues_by_severity = @analysis_data[:issues].group_by { |issue| issue[:severity] }
+      else
+        @issues_by_file = {}
+        @issues_by_severity = {}
+      end
+      
+      render 'style_patrol'
+    end
+    
+    # Force refresh of style patrol data
+    def refresh_style_patrol
+      @analysis_data = Solidstats::StylePatrolService.refresh_cache
+      redirect_to quality_style_patrol_path, notice: 'Code quality analysis refreshed successfully.'
+    rescue => e
+      redirect_to quality_style_patrol_path, alert: "Error refreshing analysis: #{e.message}"
+    end
+    
+    # Display SimpleCov code coverage analysis
+    def coverage_compass
+      # Get coverage data using the correct method
+      @analysis_data = Solidstats::CoverageCompassService.collect_data
+      
+      # Handle different response types from service
+      if @analysis_data
+        if @analysis_data[:setup_required]
+          @setup_instructions = @analysis_data[:instructions]
+          @show_setup = true
+          @analysis_data[:status] = 'setup_required'
+        elsif @analysis_data[:stale_data]
+          @stale_warning = true
+          @data_age_hours = @analysis_data[:data_age_hours]
+          @suggestions = @analysis_data[:suggestions]
+          @analysis_data = @analysis_data[:last_coverage] || @analysis_data
+          @analysis_data[:status] = 'stale'
+        elsif @analysis_data[:error]
+          @error_message = @analysis_data[:error]
+          @analysis_data[:status] = 'error'
+        else
+          @analysis_data[:status] = 'success'
+        end
+        
+        # Organize file coverage data for better display
+        organize_coverage_data
+      else
+        set_error_state
+        @analysis_data = { status: 'error' }
+      end
+      
+      render 'coverage_compass'
+    end
+    
+    # Force refresh of coverage compass data
+    def refresh_coverage_compass
+      Solidstats::CoverageCompassService.refresh_cache
+      redirect_to quality_coverage_compass_path, notice: 'Code coverage analysis refreshed successfully.'
+    rescue => e
+      redirect_to quality_coverage_compass_path, alert: "Error refreshing coverage analysis: #{e.message}"
+    end
+
+    private
+
+    def organize_coverage_data
+      file_coverage_data = @analysis_data[:file_coverage]
+      if file_coverage_data.present?
+        @file_coverage = file_coverage_data.map do |path, data|
+          {
+            file_path: path,
+            coverage_percent: data[:coverage_percentage] || 0,
+            total_lines: data[:total_lines] || 0,
+            covered_lines: data[:covered_lines] || 0,
+            missed_lines: data[:missed_lines] || []
+          }
+        end
+        
+        # Group files by coverage ranges for better visualization
+        @coverage_ranges = {
+          excellent: @file_coverage.select { |f| f[:coverage_percent] >= 90 },
+          good: @file_coverage.select { |f| f[:coverage_percent] >= 70 && f[:coverage_percent] < 90 },
+          needs_improvement: @file_coverage.select { |f| f[:coverage_percent] >= 50 && f[:coverage_percent] < 70 },
+          poor: @file_coverage.select { |f| f[:coverage_percent] < 50 }
+        }
+      else
+        @file_coverage = []
+        @coverage_ranges = { excellent: [], good: [], needs_improvement: [], poor: [] }
+      end
+      
+      # Set summary data
+      @summary = {
+        overall_coverage: @analysis_data[:overall_coverage] || 0,
+        coverage_percent: @analysis_data[:overall_coverage] || 0,
+        total_lines: @analysis_data[:total_lines] || 0,
+        covered_lines: @analysis_data[:covered_lines] || 0,
+        missed_lines: (@analysis_data[:total_lines] || 0) - (@analysis_data[:covered_lines] || 0),
+        total_files: @file_coverage.size,
+        health_score: calculate_health_score(@analysis_data[:overall_coverage] || 0),
+        coverage_grade: determine_coverage_grade(@analysis_data[:overall_coverage] || 0)
+      }
+    end
+
+    def set_error_state
+      @error_message = "Failed to retrieve coverage data"
+      @file_coverage = []
+      @coverage_ranges = { excellent: [], good: [], needs_improvement: [], poor: [] }
+      @summary = { 
+        overall_coverage: 0, 
+        coverage_percent: 0,
+        total_lines: 0, 
+        covered_lines: 0, 
+        missed_lines: 0,
+        total_files: 0,
+        health_score: 0,
+        coverage_grade: 'F'
+      }
+    end
+
+    def calculate_health_score(coverage_percent)
+      case coverage_percent
+      when 90..100 then 95
+      when 80..89 then 85
+      when 70..79 then 75
+      when 60..69 then 65
+      when 50..59 then 55
+      else 25
+      end
+    end
+
+    def determine_coverage_grade(coverage_percent)
+      case coverage_percent
+      when 90..100 then 'A+'
+      when 80..89 then 'A'
+      when 70..79 then 'B'
+      when 60..69 then 'C'
+      when 50..59 then 'D'
+      else 'F'
+      end
+    end
+  end
+end

data/app/controllers/solidstats/securities_controller.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Solidstats
+  class SecuritiesController < ApplicationController
+    layout 'solidstats/dashboard'
+    
+    # Display bundler audit security vulnerabilities
+    def bundler_audit
+      @vulnerabilities_data = Solidstats::BundlerAuditService.fetch_vulnerabilities
+      @vulnerabilities = @vulnerabilities_data.dig("output", "results") || []
+      @summary = Solidstats::BundlerAuditService.summary
+      @last_updated = @vulnerabilities_data.dig("output", "created_at")
+      
+      # Group vulnerabilities by severity for better display
+      @vulnerabilities_by_severity = @vulnerabilities.group_by do |vuln|
+        vuln.dig("advisory", "criticality") || "unknown"
+      end
+      
+      render 'bundler_audit'
+    end
+    
+    # Force refresh of bundler audit data
+    def refresh_bundler_audit
+      @vulnerabilities_data = Solidstats::BundlerAuditService.scan_and_cache
+      redirect_to securities_bundler_audit_path, notice: 'Security vulnerabilities refreshed successfully.'
+    rescue => e
+      redirect_to securities_bundler_audit_path, alert: "Error refreshing vulnerabilities: #{e.message}"
+    end
+  end
+end

data/app/helpers/solidstats/application_helper.rb

@@ -1,16 +1,52 @@
 module Solidstats
   module ApplicationHelper
+    def time_ago_in_words(from_time)
+      return "just now" if from_time.nil?
+      
+      distance_in_seconds = (Time.current - from_time).to_i
+      
+      case distance_in_seconds
+      when 0..29
+        "just now"
+      when 30..59
+        "#{distance_in_seconds} seconds"
+      when 60..3599
+        minutes = distance_in_seconds / 60
+        "#{minutes} minute#{'s' if minutes != 1}"
+      when 3600..86399
+        hours = distance_in_seconds / 3600
+        "#{hours} hour#{'s' if hours != 1}"
+      else
+        days = distance_in_seconds / 86400
+        "#{days} day#{'s' if days != 1}"
+      end
+    end
+
+    def quick_actions
+      [
+        { icon: 'refresh-ccw', label: 'Refresh All', color: 'blue' },
+        { icon: 'download', label: 'Export Data', color: 'green' },
+        { icon: 'bar-chart-2', label: 'View Reports', color: 'purple' },
+        { icon: 'tool', label: 'Settings', color: 'orange' }
+      ]
+    end
+
     # Inline CSS helper - reads all CSS files and returns them as a style tag
     def solidstats_styles
       return @solidstats_styles_cache if defined?(@solidstats_styles_cache)
 
       begin
         engine_root = Solidstats::Engine.root
-        css_files = Dir.glob("#{engine_root}/app/assets/stylesheets/solidstats/components/*.css")
+        css_files = Dir.glob("#{engine_root}/app/assets/stylesheets/solidstats/*.css")
 
         combined_css = css_files.map do |file_path|
-          "/* === #{File.basename(file_path)} === */\n#{File.read(file_path)}"
-        end.join("\n\n")
+          relative_path = file_path.gsub("#{engine_root}/app/assets/stylesheets/solidstats/", "")
+          
+          # Skip manifest files (application.css with require statements)
+          next if relative_path == "application.css"
+          
+          "/* === #{relative_path} === */\n#{File.read(file_path)}"
+        end.compact.join("\n\n")
 
         @solidstats_styles_cache = content_tag(:style, combined_css.html_safe, type: "text/css")
       rescue => e
@@ -25,22 +61,99 @@ module Solidstats
 
       begin
         engine_root = Solidstats::Engine.root
-        js_file = "#{engine_root}/app/assets/javascripts/solidstats/application.js"
+        js_files = Dir.glob("#{engine_root}/app/assets/javascripts/solidstats/**/*.js")
+
+        if js_files.any?
+          combined_js = js_files.map do |file_path|
+            relative_path = file_path.gsub("#{engine_root}/app/assets/javascripts/solidstats/", "")
+            javascript_content = File.read(file_path)
+            # Remove Sprockets directives since we're inlining
+            cleaned_js = javascript_content.gsub(/^\/\/=.*$/, "").strip
 
-        if File.exist?(js_file)
-          javascript_content = File.read(js_file)
-          # Remove Sprockets directives since we're inlining
-          cleaned_js = javascript_content.gsub(/^\/\/=.*$/, "").strip
+            "/* === #{relative_path} === */\n#{cleaned_js}"
+          end.join("\n\n")
 
-          @solidstats_scripts_cache = content_tag(:script, cleaned_js.html_safe, type: "text/javascript")
+          dashboard_js = <<~JS
+            /* === Dashboard Core Scripts === */
+            document.addEventListener('DOMContentLoaded', function() {
+              // Initialize Feather icons if available
+              if (typeof feather !== 'undefined') {
+                feather.replace();
+              }
+              
+              // Auto-refresh functionality with animations
+              setInterval(function() {
+                document.querySelectorAll('.card').forEach(function(card) {
+                  card.style.transform = 'scale(1.02)';
+                  setTimeout(function() {
+                    card.style.transform = '';
+                  }, 200);
+                });
+              }, 30000);
+
+              // Add loading states to forms
+              document.querySelectorAll('form[data-turbo-submits-with]').forEach(function(form) {
+                form.addEventListener('submit', function() {
+                  var submitBtn = form.querySelector('button[type="submit"]');
+                  if (submitBtn) {
+                    submitBtn.classList.add('loading');
+                    submitBtn.disabled = true;
+                  }
+                });
+              });
+            });
+          JS
+
+          final_js = combined_js + "\n\n" + dashboard_js
         else
-          Rails.logger.warn "Solidstats JavaScript file not found: #{js_file}"
-          content_tag(:script, "console.log('Solidstats JavaScript not found');", type: "text/javascript")
+          # No JS files found, just include dashboard scripts
+          final_js = <<~JS
+            /* === Dashboard Core Scripts === */
+            document.addEventListener('DOMContentLoaded', function() {
+              // Initialize Feather icons if available
+              if (typeof feather !== 'undefined') {
+                feather.replace();
+              }
+              
+              // Auto-refresh functionality with animations
+              setInterval(function() {
+                document.querySelectorAll('.card').forEach(function(card) {
+                  card.style.transform = 'scale(1.02)';
+                  setTimeout(function() {
+                    card.style.transform = '';
+                  }, 200);
+                });
+              }, 30000);
+
+              // Add loading states to forms
+              document.querySelectorAll('form[data-turbo-submits-with]').forEach(function(form) {
+                form.addEventListener('submit', function() {
+                  var submitBtn = form.querySelector('button[type="submit"]');
+                  if (submitBtn) {
+                    submitBtn.classList.add('loading');
+                    submitBtn.disabled = true;
+                  }
+                });
+              });
+            });
+          JS
         end
+
+        @solidstats_scripts_cache = content_tag(:script, final_js.html_safe, type: "text/javascript")
       rescue => e
         Rails.logger.error "Solidstats JavaScript loading error: #{e.message}"
         content_tag(:script, "console.error('Solidstats JavaScript loading failed: #{e.message}');", type: "text/javascript")
       end
     end
+
+    # CDN dependencies helper
+    def solidstats_cdn_dependencies
+      [
+        tag(:meta, name: "viewport", content: "width=device-width,initial-scale=1"),
+        stylesheet_link_tag("https://cdn.jsdelivr.net/npm/daisyui@4.12.10/dist/full.min.css", media: "all"),
+        javascript_include_tag("https://cdn.tailwindcss.com"),
+        javascript_include_tag("https://unpkg.com/feather-icons")
+      ].join.html_safe
+    end
   end
 end

data/app/helpers/solidstats/performance_helper.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module Solidstats
+  # LoadLens Performance Helper
+  # Provides view helpers for displaying performance metrics
+  module PerformanceHelper
+    def load_lens_status_class(avg_response_time, error_rate)
+      return 'text-error' if error_rate > 10
+      return 'text-warning' if avg_response_time > 1000
+      'text-success'
+    end
+
+    def load_lens_status_icon(avg_response_time, error_rate)
+      return 'alert-circle' if error_rate > 10
+      return 'alert-triangle' if avg_response_time > 1000
+      'check-circle'
+    end
+
+    def format_response_time(time_ms)
+      return "0ms" if time_ms.nil? || time_ms == 0
+      "#{time_ms.round(1)}ms"
+    end
+
+    def format_percentage(value)
+      return "0%" if value.nil? || value == 0
+      "#{value.round(1)}%"
+    end
+
+    def request_status_badge_class(status)
+      case status.to_i
+      when 200..299
+        'badge-success'
+      when 300..399
+        'badge-info'
+      when 400..499
+        'badge-warning'
+      when 500..599
+        'badge-error'
+      else
+        'badge-neutral'
+      end
+    end
+
+    def response_time_color_class(time_ms)
+      return 'text-base-content' if time_ms.nil? || time_ms == 0
+      
+      case time_ms.to_f
+      when 0..100
+        'text-success'
+      when 100..500
+        'text-info'
+      when 500..1000
+        'text-warning'
+      else
+        'text-error'
+      end
+    end
+
+    def performance_trend_indicator(current, previous)
+      return '' if current.nil? || previous.nil? || previous == 0
+      
+      percentage_change = ((current - previous) / previous.to_f) * 100
+      
+      if percentage_change > 5
+        content_tag(:span, '↑', class: 'text-error', title: "#{percentage_change.round(1)}% slower")
+      elsif percentage_change < -5
+        content_tag(:span, '↓', class: 'text-success', title: "#{percentage_change.abs.round(1)}% faster")
+      else
+        content_tag(:span, '→', class: 'text-info', title: 'Similar performance')
+      end
+    end
+
+    def load_lens_metric_badge(value, threshold_warning, threshold_error, unit = 'ms')
+      formatted_value = "#{value}#{unit}"
+      
+      badge_class = if value > threshold_error
+                     'badge-error'
+                   elsif value > threshold_warning
+                     'badge-warning'
+                   else
+                     'badge-success'
+                   end
+      
+      content_tag(:span, formatted_value, class: "badge #{badge_class}")
+    end
+  end
+end

data/app/helpers/solidstats/productivity_helper.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Solidstats
+  module ProductivityHelper
+    def todo_type_color(type)
+      case type.to_s.downcase
+      when 'todo' then 'primary'
+      when 'fixme' then 'error'
+      when 'hack' then 'warning'
+      when 'note' then 'info'
+      when 'bug' then 'error'
+      else 'neutral'
+      end
+    end
+    
+    def todo_type_icon(type)
+      case type.to_s.downcase
+      when 'todo' then '📝'
+      when 'fixme' then '🔧'
+      when 'hack' then '⚠️'
+      when 'note' then '📋'
+      when 'bug' then '🐛'
+      else '📌'
+      end
+    end
+    
+    def todo_priority_class(type)
+      case type.to_s.downcase
+      when 'bug' then 'priority-high'
+      when 'fixme' then 'priority-high' 
+      when 'hack' then 'priority-medium'
+      when 'todo' then 'priority-low'
+      when 'note' then 'priority-low'
+      else 'priority-low'
+      end
+    end
+  end
+end

data/app/services/solidstats/bundler_audit_service.rb

@@ -0,0 +1,206 @@
+# frozen_string_literal: true
+
+module Solidstats
+  # Service to collect and process bundler audit security vulnerability data
+  class BundlerAuditService
+    CACHE_FILE = Rails.root.join("solidstats", "bundler_audit.json")
+    CACHE_HOURS = 24 # Cache for 24 hours
+
+    class << self
+      # Get cached vulnerabilities or scan if cache is stale
+      # @return [Hash] The vulnerability data from JSON file
+      def fetch_vulnerabilities
+        if cache_stale?
+          scan_and_cache
+        end
+
+        load_cached_data
+      end
+
+      # Force a fresh scan and update cache
+      # @return [Hash] Fresh vulnerability data
+      def scan_and_cache
+        Rails.logger.info("Running bundler audit scan...")
+        
+        begin
+          vulnerabilities_data = collect_bundler_audit_data
+          save_to_cache(vulnerabilities_data)
+          update_summary_json(vulnerabilities_data)
+          vulnerabilities_data
+        rescue => e
+          Rails.logger.error("Error running bundler audit: #{e.message}")
+          { "output" => { "results" => [], "error" => e.message } }
+        end
+      end
+
+      # Get summary for dashboard display
+      # @return [Hash] Summary information with status, count, and message
+      def summary
+        data = fetch_vulnerabilities
+        results = data.dig("output", "results") || []
+        vuln_count = results.count
+
+        {
+          count: vuln_count,
+          status: determine_status(vuln_count),
+          message: generate_message(vuln_count),
+          last_updated: data.dig("output", "created_at") || Time.current
+        }
+      end
+
+      private
+
+      # Check if cache file exists and is fresh
+      # @return [Boolean] true if cache is stale or missing
+      def cache_stale?
+        return true unless File.exist?(CACHE_FILE)
+        
+        file_age = Time.current - File.mtime(CACHE_FILE)
+        file_age > CACHE_HOURS.hours
+      end
+
+      # Load data from cache file
+      # @return [Hash] Cached vulnerability data
+      def load_cached_data
+        return { "output" => { "results" => [] } } unless File.exist?(CACHE_FILE)
+        
+        JSON.parse(File.read(CACHE_FILE))
+      rescue JSON::ParserError => e
+        Rails.logger.error("Error parsing bundler audit cache: #{e.message}")
+        { "output" => { "results" => [] } }
+      end
+
+      # Run bundler audit and collect vulnerability data
+      # @return [Hash] Fresh vulnerability data
+      def collect_bundler_audit_data
+        # Run bundler audit with JSON format
+        result = `bundle audit check --update --format json 2>&1`
+        
+        # Check if bundler-audit is installed
+        if $?.exitstatus == 127 || result.include?("command not found")
+          raise "bundler-audit gem is not installed. Please run: gem install bundler-audit"
+        end
+        
+        # Extract JSON part from output (bundler-audit may include extra text)
+        json_match = result.match(/(\{.*\})/m)
+        if json_match
+          parsed_data = JSON.parse(json_match[1])
+          
+          # Add metadata
+          {
+            "output" => {
+              "version" => parsed_data.dig("version") || "unknown",
+              "created_at" => Time.current.strftime("%Y-%m-%d %H:%M:%S %z"),
+              "results" => parsed_data.dig("results") || []
+            }
+          }
+        else
+          # If no JSON found, create empty structure
+          {
+            "output" => {
+              "version" => "unknown",
+              "created_at" => Time.current.strftime("%Y-%m-%d %H:%M:%S %z"),
+              "results" => []
+            }
+          }
+        end
+      rescue JSON::ParserError => e
+        raise "Failed to parse bundler audit JSON output: #{e.message}"
+      end
+
+      # Save vulnerability data to cache file
+      # @param data [Hash] Vulnerability data to cache
+      def save_to_cache(data)
+        FileUtils.mkdir_p(File.dirname(CACHE_FILE))
+        File.write(CACHE_FILE, JSON.pretty_generate(data))
+        Rails.logger.info("Bundler audit data cached to #{CACHE_FILE}")
+      end
+
+      # Update the main summary.json file with security vulnerabilities
+      # @param data [Hash] Vulnerability data
+      def update_summary_json(data)
+        summary_file = Rails.root.join("solidstats", "summary.json")
+        
+        # Ensure directory exists
+        FileUtils.mkdir_p(File.dirname(summary_file))
+        
+        # Load existing summary or create new
+        existing_summary = if File.exist?(summary_file)
+          JSON.parse(File.read(summary_file))
+        else
+          {}
+        end
+        
+        # Get vulnerability count and status
+        results = data.dig("output", "results") || []
+        vuln_count = results.count
+        status = determine_status(vuln_count)
+        
+        # Calculate severity distribution
+        severity_counts = results.group_by { |r| r.dig("advisory", "criticality") || "unknown" }
+                                 .transform_values(&:count)
+        
+        # Create badges for severity levels
+        badges = []
+        %w[critical high medium low].each do |severity|
+          count = severity_counts[severity] || 0
+          if count > 0
+            badges << {
+              "text" => "#{severity.capitalize}: #{count}",
+              "color" => severity_badge_color(severity)
+            }
+          end
+        end
+        
+        # Update summary
+        existing_summary["Security Vulnerabilities"] = {
+          "icon" => "shield-alert",
+          "status" => status,
+          "value" => generate_message(vuln_count),
+          "last_updated" => data.dig("output", "created_at") || Time.current.iso8601,
+          "url" => "/solidstats/securities/bundler_audit",
+          "badges" => badges
+        }
+        
+        # Save updated summary
+        File.write(summary_file, JSON.pretty_generate(existing_summary))
+        Rails.logger.info("Updated summary.json with security vulnerabilities")
+      end
+
+      # Determine status color based on vulnerability count
+      # @param count [Integer] Number of vulnerabilities
+      # @return [String] Status indicator
+      def determine_status(count)
+        case count
+        when 0 then "success"
+        when 1..2 then "warning"
+        else "danger"
+        end
+      end
+
+      # Generate status message based on vulnerability count
+      # @param count [Integer] Number of vulnerabilities
+      # @return [String] Human-readable status message
+      def generate_message(count)
+        case count
+        when 0 then "No vulnerabilities"
+        when 1 then "1 vulnerability"
+        else "#{count} vulnerabilities"
+        end
+      end
+
+      # Get badge color for severity level
+      # @param severity [String] Severity level
+      # @return [String] Badge color
+      def severity_badge_color(severity)
+        case severity.downcase
+        when "critical" then "red"
+        when "high" then "orange"
+        when "medium" then "yellow"
+        when "low" then "blue"
+        else "gray"
+        end
+      end
+    end
+  end
+end