solidstats 1.1.0 → 3.0.0.beta.1

data/app/helpers/solidstats/application_helper.rb

@@ -1,4 +1,159 @@
 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/*.css")
+
+        combined_css = css_files.map do |file_path|
+          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
+        Rails.logger.error "Solidstats CSS loading error: #{e.message}"
+        content_tag(:style, "/* Solidstats CSS loading failed: #{e.message} */", type: "text/css")
+      end
+    end
+
+    # Inline JavaScript helper - reads all JS files and returns them as a script tag
+    def solidstats_scripts
+      return @solidstats_scripts_cache if defined?(@solidstats_scripts_cache)
+
+      begin
+        engine_root = Solidstats::Engine.root
+        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
+
+            "/* === #{relative_path} === */\n#{cleaned_js}"
+          end.join("\n\n")
+
+          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
+          # 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