solidstats 3.0.0.beta.1 → 3.0.0

data/lib/generators/solidstats/templates/initializer.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+# Solidstats Configuration
+# This file configures the Solidstats development dashboard
+# Documentation: https://github.com/your-org/solidstats
+
+Solidstats.configure do |config|
+  # Cache duration for dashboard data (default: 1 hour)
+  # config.cache_duration = 1.hour
+
+  # Enable ViewComponent integration (default: true)
+  # config.enable_components = true
+
+  # Log level for Solidstats operations (default: :info)
+  # Levels: :debug, :info, :warn, :error
+  # config.log_level = :info
+
+  # Enable component previews in development (default: true in development)
+  # config.enable_previews = Rails.env.development?
+
+  # Asset configuration for Rails engine compatibility
+  config.assets = {
+    # Enable asset fingerprinting in production (default: true)
+    fingerprint: Rails.env.production?,
+
+    # Asset pipeline strategy (default: :auto)
+    # Options: :sprockets, :webpacker, :importmap, :auto (auto-detect)
+    strategy: :auto,
+
+    # Enable asset precompilation for production (default: true)
+    precompile: true,
+
+    # Compile assets on demand in development (default: true in dev)
+    compile_on_demand: Rails.env.development?
+  }
+
+  # CSS framework integration (default: :none)
+  # Options: :none, :bootstrap, :tailwind
+  # config.css_framework = :none
+
+  # Security scan settings
+  # config.security = {
+  #   # Include retired gems in vulnerability scans (default: true)
+  #   include_retired: true,
+  #
+  #   # Severity levels to report (default: [:high, :medium, :low])
+  #   severity_levels: [:high, :medium, :low],
+  #
+  #   # Cache security scan results (default: 30 minutes)
+  #   cache_duration: 30.minutes
+  # }
+
+  # Code quality settings
+  # config.code_quality = {
+  #   # Enable complexity analysis (default: true)
+  #   analyze_complexity: true,
+  #
+  #   # Enable dependency analysis (default: true)
+  #   analyze_dependencies: true,
+  #
+  #   # Paths to exclude from analysis
+  #   exclude_paths: ['tmp/', 'log/', 'vendor/']
+  # }
+
+  # Task tracking settings
+  # config.tasks = {
+  #   # Patterns to scan for TODO/FIXME comments
+  #   patterns: ['TODO', 'FIXME', 'HACK', 'BUG'],
+  #
+  #   # File extensions to scan
+  #   file_extensions: ['.rb', '.erb', '.js', '.css', '.yml'],
+  #
+  #   # Paths to exclude from task scanning
+  #   exclude_paths: ['vendor/', 'node_modules/', 'tmp/']
+  # }
+
+  # Asset configuration (advanced)
+  # config.assets = {
+  #   # Enable asset fingerprinting in production (default: true)
+  #   fingerprint: Rails.env.production?,
+  #
+  #   # Asset compilation strategy
+  #   # Options: :sprockets, :webpacker, :importmap, :auto
+  #   strategy: :auto
+  # }
+end
+
+# Environment-specific configuration
+if Rails.env.development?
+  # Development-specific settings
+  Solidstats.configure do |config|
+    config.log_level = :debug
+    config.enable_previews = true
+  end
+end
+
+# Example: Custom CSS framework integration
+# Uncomment and modify based on your CSS framework
+#
+# # Bootstrap integration
+# if defined?(Bootstrap)
+#   Solidstats.configure do |config|
+#     config.css_framework = :bootstrap
+#   end
+# end
+#
+# # Tailwind CSS integration
+# if Rails.application.config.assets.css_compressor == :tailwindcss
+#   Solidstats.configure do |config|
+#     config.css_framework = :tailwind
+#   end
+# end

data/lib/solidstats/asset_compatibility.rb

@@ -0,0 +1,238 @@
+# frozen_string_literal: true
+
+module Solidstats
+  # Asset compatibility layer for Rails engines
+  # Provides universal asset loading across different Rails asset pipelines
+  module AssetCompatibility
+    extend self
+
+    # Include engine assets in host application
+    # @param app [Rails::Application] Rails application instance
+    def setup_assets(app)
+      detect_asset_pipeline(app, force_refresh: true)
+      configure_asset_pipeline(app)
+      add_asset_helpers(app)
+    end
+
+    # Detect which asset pipeline is being used
+    # @param app [Rails::Application] Rails application instance
+    # @param force_refresh [Boolean] Force refresh of cached detection
+    # @return [Symbol] Detected pipeline (:propshaft, :sprockets, :webpacker, :importmap, :unknown)
+    def detect_asset_pipeline(app, force_refresh: false)
+      if force_refresh
+        @pipeline = nil
+      end
+
+      @pipeline ||= begin
+        if propshaft_available?(app)
+          :propshaft
+        elsif importmap_available?(app)
+          :importmap
+        elsif webpacker_available?(app)
+          :webpacker
+        elsif sprockets_available?(app)
+          :sprockets
+        else
+          :unknown
+        end
+      end
+    end
+
+    # Configure the detected asset pipeline
+    # @param app [Rails::Application] Rails application instance
+    def configure_asset_pipeline(app)
+      case detect_asset_pipeline(app)
+      when :propshaft
+        configure_propshaft(app)
+      when :sprockets
+        configure_sprockets(app)
+      when :webpacker
+        configure_webpacker(app)
+      when :importmap
+        configure_importmap(app)
+      when :unknown
+        Solidstats.logger.warn "[Solidstats] No supported asset pipeline detected"
+      end
+    end
+
+    # Add universal asset helper methods
+    # @param app [Rails::Application] Rails application instance
+    def add_asset_helpers(app)
+      return unless defined?(ActionView::Base)
+
+      ActionView::Base.class_eval do
+        # Universal stylesheet helper for Solidstats
+        def solidstats_stylesheets(*args)
+          options = args.extract_options!
+          strategy = Solidstats.asset_strategy
+
+          case strategy
+          when :importmap, :sprockets, :propshaft
+            stylesheet_link_tag "solidstats/application", **options
+          when :webpacker
+            if respond_to?(:stylesheet_pack_tag)
+              stylesheet_pack_tag "solidstats/application", **options
+            else
+              stylesheet_link_tag "solidstats/application", **options
+            end
+          else
+            stylesheet_link_tag "solidstats/application", **options
+          end
+        end
+
+        # Universal javascript helper for Solidstats
+        def solidstats_javascripts(*args)
+          options = args.extract_options!
+          strategy = Solidstats.asset_strategy
+
+          case strategy
+          when :importmap
+            javascript_importmap_tags
+            javascript_include_tag "solidstats", **options
+          when :webpacker
+            if respond_to?(:javascript_pack_tag)
+              javascript_pack_tag "solidstats/application", **options
+            else
+              javascript_include_tag "solidstats/application", **options
+            end
+          when :sprockets, :propshaft
+            javascript_include_tag "solidstats/application", **options
+          else
+            javascript_include_tag "solidstats/application", **options
+          end
+        end
+
+        # Convenience method to include all Solidstats assets
+        def solidstats_assets(*args)
+          options = args.extract_options!
+
+          content = []
+          content << solidstats_stylesheets(**options.slice(:media, :crossorigin))
+          content << solidstats_javascripts(**options.slice(:defer, :async, :crossorigin))
+
+          safe_join(content, "\n")
+        end
+      end
+
+      Solidstats.logger.info "[Solidstats] Added universal asset helpers"
+    rescue => e
+      Solidstats.logger.warn "[Solidstats] Could not add asset helpers: #{e.message}"
+    end
+
+    private
+
+    # Check if Propshaft is available
+    def propshaft_available?(app)
+      defined?(Propshaft) && app.config.respond_to?(:assets) &&
+        app.assets.is_a?(Propshaft::Assembly)
+    end
+
+    # Check if Importmap is available
+    def importmap_available?(app)
+      defined?(Importmap) &&
+        app.config.respond_to?(:importmap) &&
+        File.exist?(Rails.root.join("config/importmap.rb"))
+    end
+
+    # Check if Webpacker is available
+    def webpacker_available?(app)
+      defined?(Webpacker) &&
+        app.config.respond_to?(:webpacker) &&
+        File.exist?(Rails.root.join("config/webpacker.yml"))
+    end
+
+    # Check if Sprockets is available
+    def sprockets_available?(app)
+      defined?(Sprockets) && app.config.respond_to?(:assets) &&
+        !propshaft_available?(app)
+    end
+
+    # Configure Propshaft asset pipeline
+    def configure_propshaft(app)
+      return unless app.config.respond_to?(:assets)
+
+      # Add engine asset paths
+      engine_paths = [
+        Solidstats::Engine.root.join("app", "assets", "stylesheets"),
+        Solidstats::Engine.root.join("app", "assets", "javascripts"),
+        Solidstats::Engine.root.join("app", "assets", "images")
+      ]
+
+      engine_paths.each do |path|
+        path_str = path.to_s
+        unless app.config.assets.paths.include?(path_str)
+          app.config.assets.paths << path_str
+        end
+      end
+
+      # Add to precompile list
+      precompile_assets = [
+        "solidstats/application.css",
+        "solidstats/application.js"
+      ]
+
+      precompile_assets.each do |asset|
+        unless app.config.assets.precompile.include?(asset)
+          app.config.assets.precompile << asset
+        end
+      end
+
+      Solidstats.logger.info "[Solidstats] Configured Propshaft asset pipeline"
+    end
+
+    # Configure Sprockets asset pipeline
+    def configure_sprockets(app)
+      return unless app.config.respond_to?(:assets)
+
+      # Add engine asset paths
+      engine_paths = [
+        Solidstats::Engine.root.join("app", "assets", "stylesheets"),
+        Solidstats::Engine.root.join("app", "assets", "javascripts"),
+        Solidstats::Engine.root.join("app", "assets", "images")
+      ]
+
+      engine_paths.each do |path|
+        path_str = path.to_s
+        unless app.config.assets.paths.include?(path_str)
+          app.config.assets.paths << path_str
+        end
+      end
+
+      # Add to precompile list
+      precompile_assets = [
+        "solidstats/application.css",
+        "solidstats/application.js"
+      ]
+
+      precompile_assets.each do |asset|
+        unless app.config.assets.precompile.include?(asset)
+          app.config.assets.precompile << asset
+        end
+      end
+
+      Solidstats.logger.info "[Solidstats] Configured Sprockets asset pipeline"
+    end
+
+    # Configure Webpacker asset pipeline
+    def configure_webpacker(app)
+      # Webpacker configuration is more complex and typically requires
+      # manual setup in the host application
+      Solidstats.logger.info "[Solidstats] Webpacker detected - manual configuration may be required"
+
+      # Add source path if possible
+      if app.config.webpacker.respond_to?(:source_path)
+        engine_source = Solidstats::Engine.root.join("app", "javascript")
+        if engine_source.exist?
+          Solidstats.logger.info "[Solidstats] Engine JavaScript available at: #{engine_source}"
+        end
+      end
+    end
+
+    # Configure Importmap asset pipeline
+    def configure_importmap(app)
+      # Importmap configuration is handled through config/importmap.rb
+      # The generator should add the appropriate pin statements
+      Solidstats.logger.info "[Solidstats] Importmap detected - configuration in config/importmap.rb"
+    end
+  end
+end

data/lib/solidstats/asset_manifest.rb

@@ -0,0 +1,205 @@
+# frozen_string_literal: true
+
+# Solidstats Asset Manifest
+# This file defines all assets that should be precompiled for production deployment
+# Compatible with Sprockets, Webpacker, and Importmap
+
+module Solidstats
+  class AssetManifest
+    # Define all assets that should be precompiled
+    PRECOMPILE_ASSETS = [
+      # Main application assets
+      "solidstats/application.css",
+      "solidstats/application.js",
+
+      # Component-specific CSS files (using actual filenames)
+      "solidstats/components/summary_card.css",
+      "solidstats/components/dashboard_layout.css",
+      "solidstats/components/tab_navigation.css",
+      "solidstats/components/quick_navigation.css",
+      "solidstats/components/action_button.css",
+      "solidstats/components/dashboard_header.css",
+      "solidstats/components/navigation.css",
+      "solidstats/components/security.css",
+      "solidstats/components/status_badge.css",
+      "solidstats/components/dashboard.css"
+    ].freeze
+
+    # Assets that should be included in development mode
+    DEVELOPMENT_ASSETS = [
+      # Preview and development-only assets
+      "solidstats/component_preview.css",
+      "solidstats/development_toolbar.css"
+    ].freeze
+
+    # Image assets to precompile
+    IMAGE_ASSETS = [
+      # Add image assets here when they exist
+      # "solidstats/icons/*.png",
+      # "solidstats/logos/*.svg"
+    ].freeze
+
+    class << self
+      # Get all assets for precompilation based on environment
+      # @param environment [String] Rails environment
+      # @return [Array<String>] Assets to precompile
+      def assets_for_environment(environment = Rails.env)
+        assets = PRECOMPILE_ASSETS.dup
+
+        if environment == "development"
+          assets.concat(DEVELOPMENT_ASSETS)
+        end
+
+        assets.concat(IMAGE_ASSETS)
+        assets.uniq
+      end
+
+      # Configure asset precompilation for a Rails application
+      # @param app [Rails::Application] Rails application instance
+      def configure_precompilation(app)
+        return unless app.config.respond_to?(:assets)
+
+        assets_to_add = assets_for_environment - app.config.assets.precompile
+
+        assets_to_add.each do |asset|
+          app.config.assets.precompile << asset
+        end
+
+        # Add asset paths if not already present
+        add_asset_paths(app)
+
+        Rails.logger.info "[Solidstats] Added #{assets_to_add.size} assets to precompilation list"
+      end
+
+      # Add engine asset paths to application
+      # @param app [Rails::Application] Rails application instance
+      def add_asset_paths(app)
+        return unless app.config.respond_to?(:assets)
+
+        engine_paths = [
+          Solidstats::Engine.root.join("app", "assets", "stylesheets"),
+          Solidstats::Engine.root.join("app", "assets", "javascripts"),
+          Solidstats::Engine.root.join("app", "assets", "images")
+        ]
+
+        engine_paths.each do |path|
+          path_str = path.to_s
+          unless app.config.assets.paths.include?(path_str)
+            app.config.assets.paths << path_str
+          end
+        end
+      end
+
+      # Get asset fingerprinting configuration
+      # @param environment [String] Rails environment
+      # @return [Hash] Fingerprinting configuration
+      def fingerprint_config(environment = Rails.env)
+        case environment
+        when "production"
+          {
+            digest: true,
+            compile: false,
+            compress: true,
+            gzip: true
+          }
+        when "staging"
+          {
+            digest: true,
+            compile: false,
+            compress: true,
+            gzip: false
+          }
+        when "development"
+          {
+            digest: false,
+            compile: true,
+            compress: false,
+            gzip: false,
+            debug: true
+          }
+        when "test"
+          {
+            digest: false,
+            compile: true,
+            compress: false,
+            gzip: false,
+            debug: false
+          }
+        else
+          # Default safe configuration
+          {
+            digest: true,
+            compile: false,
+            compress: true,
+            gzip: false
+          }
+        end
+      end
+
+      # Apply fingerprinting configuration to application
+      # @param app [Rails::Application] Rails application instance
+      # @param environment [String] Rails environment
+      def configure_fingerprinting(app, environment = Rails.env)
+        return unless app.config.respond_to?(:assets)
+
+        config = fingerprint_config(environment)
+
+        config.each do |key, value|
+          if app.config.assets.respond_to?("#{key}=")
+            app.config.assets.public_send("#{key}=", value)
+          end
+        end
+
+        Rails.logger.info "[Solidstats] Applied #{environment} asset fingerprinting configuration"
+      end
+
+      # Check if all required assets exist
+      # @return [Array<String>] Missing assets
+      def missing_assets
+        missing = []
+
+        PRECOMPILE_ASSETS.each do |asset|
+          asset_path = resolve_asset_path(asset)
+          unless File.exist?(asset_path)
+            missing << asset
+          end
+        end
+
+        missing
+      end
+
+      # Validate that all assets are available
+      # @raise [Solidstats::Error] If required assets are missing
+      def validate_assets!
+        missing = missing_assets
+
+        unless missing.empty?
+          raise Solidstats::Error,
+                "Missing required assets: #{missing.join(', ')}"
+        end
+
+        true
+      end
+
+      private
+
+      # Resolve the file system path for an asset
+      # @param asset [String] Asset logical path
+      # @return [String] File system path
+      def resolve_asset_path(asset)
+        # Remove the 'solidstats/' prefix and find the actual file
+        relative_path = asset.sub(/^solidstats\//, "")
+
+        # Try different possible locations
+        possible_paths = [
+          Solidstats::Engine.root.join("app", "assets", "stylesheets", "solidstats", relative_path),
+          Solidstats::Engine.root.join("app", "assets", "javascripts", "solidstats", relative_path),
+          Solidstats::Engine.root.join("app", "assets", "images", "solidstats", relative_path)
+        ]
+
+        possible_paths.find { |path| File.exist?(path) } ||
+          Solidstats::Engine.root.join("app", "assets", "stylesheets", asset).to_s
+      end
+    end
+  end
+end

data/lib/solidstats/engine.rb

@@ -1,22 +1,62 @@
+# frozen_string_literal: true
+
+require "rails/engine" if defined?(Rails)
+
 module Solidstats
   class Engine < ::Rails::Engine
-    isolate_namespace Solidstats
+    isolate_namespace Solidstats if defined?(Rails)
 
-    initializer "solidstats.only_in_dev" do
+    # Engine configuration
+    config.solidstats = ActiveSupport::OrderedOptions.new
+
+    # Set default configuration values
+    config.before_configuration do
+      config.solidstats.cache_duration = 1.hour
+      config.solidstats.enable_components = true
+      config.solidstats.log_level = :info
+      config.solidstats.enable_previews = Rails.env.development?
+    end
+
+    # Ensure gem only runs in development environment
+    initializer "solidstats.environment_check", before: :load_config_initializers do
       unless Rails.env.development?
-        raise "Solidstats can only be used in development mode."
+        raise Solidstats::ConfigurationError,
+              "Solidstats can only be used in development mode. Current environment: #{Rails.env}"
       end
     end
 
+    # Add custom paths for autoloading
+    initializer "solidstats.autoload_paths" do |app|
+      app.config.autoload_paths += Dir[Engine.root.join("app", "components", "**")]
+      app.config.autoload_paths += Dir[Engine.root.join("app", "services", "**")]
+    end
+
+    # Add custom generators path
+    config.generators do |g|
+      g.test_framework :minitest, spec: false, fixture: false
+    end
+
+    # Isolate the Solidstats engine's namespace
+    isolate_namespace Solidstats
+
+    # Set up Solidstats asset precompilation
     initializer "solidstats.assets.precompile" do |app|
-      if Rails.env.development?
-        app.config.assets.precompile += %w[ solidstats/application.css ]
-      end
+      app.config.assets.precompile += %w[solidstats/application.css]
+    end
+
+    private
+
+    # Logging helpers with consistent formatting
+    def log_info(message)
+      Rails.logger&.info("[Solidstats] #{message}")
+    end
+
+    def log_error(message)
+      Rails.logger&.error("[Solidstats] #{message}")
     end
 
-    # Load the solidstats rake tasks
-    rake_tasks do
-      Dir[File.join(File.dirname(__FILE__), "../tasks/**/*.rake")].each { |f| load f }
+    def log_debug(message)
+      Rails.logger&.debug("[Solidstats] #{message}")
     end
   end
 end

data/lib/solidstats/version.rb

@@ -1,3 +1,3 @@
 module Solidstats
-  VERSION = "3.0.0.beta.1"
+  VERSION = "3.0.0"
 end

data/lib/solidstats.rb

@@ -1,18 +1,31 @@
 require "solidstats/version"
 require "solidstats/engine"
 
+# Top-level module for Solidstats gem
 module Solidstats
-  class << self
-    # Returns the absolute path to this gem's root directory
-    # @return [String] Gem root path
-    def root
-      File.dirname(__dir__)
-    end
+  # Gem setup
+  extend self
 
-    # Returns version string
-    # @return [String] Version
-    def version
-      VERSION
-    end
+  # Gem version
+  def version
+    VERSION
+  end
+
+  # Simple logger for internal use
+  def logger
+    @logger ||= Logger.new($stdout)
+  end
+
+  # Error classes for Solidstats specific exceptions
+  class Error < StandardError; end
+  class ComponentError < Error; end
+  class ServiceError < Error; end
+
+  # Load and initialize Solidstats in a Rails environment
+  def self.load!
+    nil unless defined?(Rails)
   end
 end
+
+# Load Solidstats automatically when Rails is loaded
+Solidstats.load! if defined?(Rails)