solidstats 1.0.0 → 2.0.0

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,127 @@
+# 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)
+
+    # 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
 
-    initializer "solidstats.only_in_dev" do
+    # 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
 
-    initializer "solidstats.assets.precompile" do |app|
-      if Rails.env.development?
-        app.config.assets.precompile += %w[ solidstats/application.css ]
-      end
+    # Load and configure ViewComponent if available
+    initializer "solidstats.setup_view_component", after: :load_config_initializers do |app|
+      setup_view_component(app) if view_component_available?
+    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
 
-    # Load the solidstats rake tasks
+    # Load custom rake tasks
     rake_tasks do
-      Dir[File.join(File.dirname(__FILE__), "../tasks/**/*.rake")].each { |f| load f }
+      load_rake_tasks
+    end
+
+    # Add custom generators path
+    config.generators do |g|
+      g.test_framework :minitest, spec: false, fixture: false
+    end
+
+    private
+
+    # Check if ViewComponent is available and properly loaded
+    # @return [Boolean] true if ViewComponent is available
+    def view_component_available?
+      defined?(ViewComponent::Base) && Solidstats.view_component_available?
+    end
+
+    # Configure ViewComponent integration
+    # @param app [Rails::Application] Rails application instance
+    def setup_view_component(app)
+      log_info "🔍 Solidstats: Setting up ViewComponent integration..."
+
+      begin
+        version = ViewComponent::VERSION rescue "unknown"
+        log_info "✅ ViewComponent #{version} detected and configured"
+
+        configure_view_component_settings(app)
+        setup_preview_paths(app)
+
+        log_info "🎯 ViewComponent::Base: #{ViewComponent::Base}"
+      rescue StandardError => e
+        log_error "❌ ViewComponent setup failed: #{e.message}"
+        raise Solidstats::ComponentError, "Failed to configure ViewComponent: #{e.message}"
+      end
+    end
+
+    # Configure ViewComponent specific settings
+    # @param app [Rails::Application] Rails application instance
+    def configure_view_component_settings(app)
+      return unless app.config.respond_to?(:view_component)
+
+      view_component_config = app.config.view_component
+      view_component_config.show_previews = config.solidstats.enable_previews
+      view_component_config.default_preview_layout = "solidstats/component_preview"
+
+      # Set preview controller if not already set
+      unless view_component_config.preview_controller
+        view_component_config.preview_controller = "Solidstats::ComponentPreviewsController"
+      end
+    end
+
+    # Setup preview paths for component development
+    # @param app [Rails::Application] Rails application instance
+    def setup_preview_paths(app)
+      return unless app.config.respond_to?(:view_component) && config.solidstats.enable_previews
+
+      preview_path = Engine.root.join("app", "components", "solidstats", "previews")
+
+      unless app.config.view_component.preview_paths.include?(preview_path)
+        app.config.view_component.preview_paths << preview_path
+        log_info "📁 Added preview path: #{preview_path}"
+      end
+    end
+
+    # Load custom rake tasks
+    def load_rake_tasks
+      task_files = Dir[Engine.root.join("lib", "tasks", "**", "*.rake")]
+      task_files.each { |file| load file }
+
+      log_info "📋 Loaded #{task_files.size} rake task(s)" if task_files.any?
+    rescue StandardError => e
+      log_error "Failed to load rake tasks: #{e.message}"
+    end
+
+    # 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
+
+    def log_debug(message)
+      Rails.logger&.debug("[Solidstats] #{message}")
     end
   end
 end

data/lib/solidstats/version.rb

@@ -1,3 +1,3 @@
 module Solidstats
-  VERSION = "1.0.0"
+  VERSION = "2.0.0"
 end