solidstats 2.0.0 → 3.0.0

data/lib/generators/solidstats/feature/templates/preview.rb.erb

@@ -1,107 +0,0 @@
-module Solidstats
-  module Previews
-    class <%= class_name %>ComponentPreview < ViewComponent::Preview
-      # Preview for dashboard summary component
-      # @label Summary View
-      def default
-        render Solidstats::<%= class_name %>Component.new(
-          data: sample_data
-        )
-      end
-
-      # Preview with warning status
-      # @label Warning State
-      def warning_state
-        render Solidstats::<%= class_name %>Component.new(
-          data: sample_data.merge(
-            status: :warning,
-            value: 75
-          )
-        )
-      end
-
-      # Preview with danger status
-      # @label Danger State
-      def danger_state
-        render Solidstats::<%= class_name %>Component.new(
-          data: sample_data.merge(
-            status: :danger,
-            value: 150
-          )
-        )
-      end
-
-      # Preview with error state
-      # @label Error State
-      def error_state
-        render Solidstats::<%= class_name %>Component.new(
-          data: {
-            value: 0,
-            count: 0,
-            items: [],
-            status: :error,
-            error: "Unable to collect data",
-            last_updated: 2.hours.ago
-          }
-        )
-      end
-
-      # Preview with no data
-      # @label Empty State
-      def empty_state
-        render Solidstats::<%= class_name %>Component.new(
-          data: {
-            value: 0,
-            count: 0,
-            items: [],
-            status: :ok,
-            last_updated: Time.current
-          }
-        )
-      end
-
-      private
-
-      def sample_data
-        {
-          value: 42,
-          count: 8,
-          status: :ok,
-          last_updated: 30.minutes.ago,
-          items: [
-            {
-              name: "Sample Item 1",
-              value: 15,
-              category: "important",
-              description: "This is a sample item for preview"
-            },
-            {
-              name: "Sample Item 2", 
-              value: 8,
-              category: "normal",
-              description: "Another sample item"
-            },
-            {
-              name: "Sample Item 3",
-              value: 12,
-              category: "important",
-              description: "Third sample item"
-            },
-            {
-              name: "Sample Item 4",
-              value: 3,
-              category: "low",
-              description: "Fourth sample item"
-            },
-            {
-              name: "Sample Item 5",
-              value: 7,
-              category: "normal",
-              description: "Fifth sample item"
-            }
-          ]
-        }
-      end
-    end
-  end
-end

data/lib/generators/solidstats/feature/templates/service.rb.erb

@@ -1,132 +0,0 @@
-module Solidstats
-  class <%= class_name %>Service
-    CACHE_KEY = "solidstats_<%= file_name %>".freeze
-    CACHE_HOURS = <%= options[:cache_hours] %>
-
-    def initialize
-      @cache_file = Rails.root.join("tmp", "#{CACHE_KEY}.json")
-    end
-
-    # Fetch cached data or collect fresh data
-    def fetch(force_refresh = false)
-      if force_refresh || cache_expired?
-        data = collect_data
-        cache_data(data)
-        data
-      else
-        cached_data
-      end
-    end
-
-    # Get summary data for dashboard cards
-    def summary
-      data = fetch
-      {
-        value: calculate_summary_value(data),
-        status: determine_status(data),
-        last_updated: data[:last_updated] || Time.current,
-        count: data[:count] || 0
-      }
-    end
-
-    # Collect detailed data for full view
-    def detailed_data
-      fetch.merge(
-        breakdown: calculate_breakdown(fetch),
-        trends: calculate_trends(fetch)
-      )
-    end
-
-    private
-
-    def collect_data
-      # TODO: Implement your data collection logic here
-      # This is where you'd gather metrics, run system commands, 
-      # analyze files, or call external APIs
-      
-      {
-        value: sample_value,
-        count: sample_count,
-        items: sample_items,
-        last_updated: Time.current,
-        status: :ok
-      }
-    rescue StandardError => e
-      Rails.logger.error "Error collecting <%= file_name %> data: #{e.message}"
-      {
-        value: 0,
-        count: 0,
-        items: [],
-        last_updated: Time.current,
-        status: :error,
-        error: e.message
-      }
-    end
-
-    def calculate_summary_value(data)
-      # TODO: Customize how the main metric is calculated
-      data[:value] || 0
-    end
-
-    def determine_status(data)
-      # TODO: Implement your status logic
-      # Return :ok, :warning, or :danger based on your metrics
-      
-      return :error if data[:error]
-      return :ok if data[:value].to_i < 50
-      return :warning if data[:value].to_i < 100
-      :danger
-    end
-
-    def calculate_breakdown(data)
-      # TODO: Implement breakdown analysis for detailed view
-      data[:items]&.group_by { |item| item[:category] } || {}
-    end
-
-    def calculate_trends(data)
-      # TODO: Implement trend analysis
-      # This could compare with historical data
-      []
-    end
-
-    # Sample data methods - replace with your actual logic
-    def sample_value
-      rand(1..100)
-    end
-
-    def sample_count
-      rand(1..20)
-    end
-
-    def sample_items
-      (1..sample_count).map do |i|
-        {
-          name: "Item #{i}",
-          value: rand(1..10),
-          category: ["category_a", "category_b", "category_c"].sample,
-          created_at: Time.current - rand(24).hours
-        }
-      end
-    end
-
-    # Cache management
-    def cache_expired?
-      return true unless @cache_file.exist?
-      
-      File.mtime(@cache_file) < CACHE_HOURS.hours.ago
-    end
-
-    def cached_data
-      return {} unless @cache_file.exist?
-      
-      JSON.parse(File.read(@cache_file)).deep_symbolize_keys
-    rescue JSON::ParserError
-      {}
-    end
-
-    def cache_data(data)
-      FileUtils.mkdir_p(@cache_file.dirname)
-      File.write(@cache_file, data.to_json)
-    end
-  end
-end

data/lib/generators/solidstats/feature/templates/service_test.rb.erb

@@ -1,109 +0,0 @@
-require "test_helper"
-
-module Solidstats
-  class <%= class_name %>ServiceTest < ActiveSupport::TestCase
-    def setup
-      @service = <%= class_name %>Service.new
-    end
-
-    test "should initialize properly" do
-      assert_not_nil @service
-    end
-
-    test "should fetch data without errors" do
-      data = @service.fetch
-      
-      assert_not_nil data
-      assert_kind_of Hash, data
-      assert data.key?(:value)
-      assert data.key?(:count)
-      assert data.key?(:items)
-      assert data.key?(:last_updated)
-      assert data.key?(:status)
-    end
-
-    test "should return summary data" do
-      summary = @service.summary
-      
-      assert_not_nil summary
-      assert_kind_of Hash, summary
-      assert summary.key?(:value)
-      assert summary.key?(:status)
-      assert summary.key?(:last_updated)
-      assert summary.key?(:count)
-    end
-
-    test "should return detailed data" do
-      detailed = @service.detailed_data
-      
-      assert_not_nil detailed
-      assert_kind_of Hash, detailed
-      assert detailed.key?(:value)
-      assert detailed.key?(:items)
-      assert detailed.key?(:breakdown)
-      assert detailed.key?(:trends)
-    end
-
-    test "should handle force refresh" do
-      # Test that force refresh bypasses cache
-      data1 = @service.fetch(false)
-      data2 = @service.fetch(true)
-      
-      assert_not_nil data1
-      assert_not_nil data2
-      assert_kind_of Hash, data1
-      assert_kind_of Hash, data2
-    end
-
-    test "should determine status correctly" do
-      summary = @service.summary
-      
-      assert_includes [:ok, :warning, :danger, :error], summary[:status]
-    end
-
-    test "should handle errors gracefully" do
-      # Mock an error condition
-      @service.stub(:collect_data, -> { raise StandardError.new("Test error") }) do
-        data = @service.fetch
-        
-        assert_equal :error, data[:status]
-        assert_equal "Test error", data[:error]
-        assert_equal 0, data[:value]
-        assert_equal 0, data[:count]
-        assert_empty data[:items]
-      end
-    end
-
-    test "should cache data properly" do
-      # Test caching behavior
-      first_fetch = @service.fetch
-      
-      # Mock cache file existence
-      cache_file = @service.instance_variable_get(:@cache_file)
-      assert_not_nil cache_file
-      
-      # Subsequent fetch should use cache if not expired
-      second_fetch = @service.fetch
-      assert_equal first_fetch[:last_updated], second_fetch[:last_updated]
-    end
-
-    test "should validate data structure" do
-      data = @service.fetch
-      
-      # Validate required fields
-      assert_respond_to data[:value], :to_i
-      assert_respond_to data[:count], :to_i
-      assert_kind_of Array, data[:items]
-      assert_kind_of Time, data[:last_updated]
-      
-      # Validate items structure if present
-      if data[:items].any?
-        data[:items].each do |item|
-          assert_kind_of Hash, item
-          assert item.key?(:name)
-          assert item.key?(:value)
-        end
-      end
-    end
-  end
-end

data/lib/generators/solidstats/install_generator.rb

@@ -1,109 +0,0 @@
-# frozen_string_literal: true
-
-require "rails/generators/base"
-
-module Solidstats
-  module Generators
-    class InstallGenerator < Rails::Generators::Base
-      desc "Install Solidstats in your Rails application"
-
-      source_root File.expand_path("templates", __dir__)
-
-      class_option :css_framework, type: :string, default: "none",
-                   desc: "CSS framework integration (none, bootstrap, tailwind)"
-      class_option :skip_assets, type: :boolean, default: false,
-                   desc: "Skip asset configuration"
-      class_option :skip_routes, type: :boolean, default: false,
-                   desc: "Skip route mounting"
-
-      def check_environment
-        unless Rails.env.development?
-          say "⚠️  Warning: Solidstats is designed for development environments only.", :yellow
-          say "Current environment: #{Rails.env}", :yellow
-
-          unless yes? "Continue installation anyway? (y/n)"
-            say "Installation cancelled.", :red
-            exit 1
-          end
-        end
-      end
-
-      def check_dependencies
-        say "🔍 Checking dependencies...", :green
-
-        # Check Rails version
-        rails_version = Rails::VERSION::STRING
-        if Gem::Version.new(rails_version) < Gem::Version.new("6.1.0")
-          say "❌ Rails #{rails_version} is not supported. Minimum version: 6.1.0", :red
-          exit 1
-        end
-        say "✅ Rails #{rails_version} supported", :green
-
-        # Check ViewComponent
-        begin
-          require "view_component"
-          say "✅ ViewComponent #{ViewComponent::VERSION} detected", :green
-        rescue LoadError
-          say "❌ ViewComponent not found. Please add it to your Gemfile:", :red
-          say "gem 'view_component'", :yellow
-          exit 1
-        end
-      end
-
-      def mount_engine
-        return if options[:skip_routes]
-
-        say "🛤️  Mounting Solidstats engine...", :green
-
-        route_content = "  mount Solidstats::Engine => '/solidstats' if Rails.env.development?"
-
-        if File.read("config/routes.rb").include?("Solidstats::Engine")
-          say "⚠️  Solidstats engine already mounted in routes.rb", :yellow
-        else
-          route route_content
-          say "✅ Engine mounted at /solidstats (development only)", :green
-        end
-      end
-
-      def configure_assets
-        say "📦 Configuring assets...", :green
-
-        say "  ✅ Using inline asset delivery (no configuration needed)", :blue
-        say "  📝 Assets are automatically included via helper methods", :blue
-
-        say "✅ Asset configuration complete", :green
-      end
-
-      def create_initializer
-        say "⚙️  Creating initializer...", :green
-
-        template "initializer.rb", "config/initializers/solidstats.rb"
-        say "✅ Created config/initializers/solidstats.rb", :green
-      end
-
-      def show_installation_complete
-        say "\n🎉 Solidstats installation complete!", :green
-        say "━" * 50, :green
-
-        say "\n📍 Next steps:", :cyan
-        say "1. Start your Rails server: rails server", :white
-        say "2. Visit: http://localhost:3000/solidstats", :white
-        say "3. Customize settings in config/initializers/solidstats.rb", :white
-
-        say "\n💡 Asset Delivery:", :cyan
-        say "  • CSS and JavaScript are automatically inlined", :white
-        say "  • No asset pipeline configuration needed", :white
-        say "  • Works with any Rails asset setup", :white
-
-        say "\n📚 Documentation: https://github.com/your-org/solidstats", :cyan
-        say "━" * 50, :green
-      end
-
-      private
-
-      def css_framework_integration_available?
-        %w[bootstrap tailwind].include?(options[:css_framework])
-      end
-    end
-  end
-end

data/lib/tasks/solidstats_install.rake

@@ -1,133 +0,0 @@
-
-# frozen_string_literal: true
-
-namespace :solidstats do
-  desc "Install Solidstats in the current Rails application"
-  task :install do
-    puts "🚀 Installing Solidstats..."
-
-    # Check Rails environment
-    unless Rails.env.development?
-      puts "⚠️  Warning: Solidstats is designed for development environments."
-      puts "Current environment: #{Rails.env}"
-    end
-
-    # Run the generator
-    if system("rails generate solidstats:install")
-      puts "\n✅ Solidstats installation completed successfully!"
-      puts "   Start your Rails server and visit http://localhost:3000/solidstats\n\n"
-    else
-      puts "\n❌ Solidstats installation failed. Please try running manually:"
-      puts "   bundle exec rails generate solidstats:install\n\n"
-    end
-  end
-
-  desc "Validate Solidstats installation and configuration"
-  task validate: :environment do
-    puts "🔍 Validating Solidstats installation..."
-
-    begin
-      # Check basic configuration
-      Solidstats.configuration
-      puts "✅ Configuration loaded"
-
-      # Check ViewComponent availability
-      if Solidstats.view_component_available?
-        version = defined?(ViewComponent::VERSION) ? ViewComponent::VERSION : "unknown"
-        puts "✅ ViewComponent available (#{version})"
-      else
-        puts "❌ ViewComponent not available"
-      end
-
-      # Check asset strategy
-      strategy = Solidstats.asset_strategy
-      puts "✅ Asset strategy: #{strategy}"
-
-      # Validate asset manifest
-      Solidstats::AssetManifest.validate_assets!
-      puts "✅ All required assets present"
-
-      # Check routes
-      if Rails.application.routes.routes.any? { |r| r.path.spec.to_s.include?("solidstats") }
-        puts "✅ Routes mounted"
-      else
-        puts "⚠️  Routes not mounted - add 'mount Solidstats::Engine => \"/solidstats\"' to config/routes.rb"
-      end
-
-      puts "\n🎉 Solidstats validation complete!"
-
-    rescue => e
-      puts "❌ Validation failed: #{e.message}"
-      exit 1
-    end
-  end
-
-  desc "Show asset configuration information"
-  task assets: :environment do
-    puts "📦 Solidstats Asset Configuration"
-    puts "=" * 40
-
-    puts "Asset Strategy: #{Solidstats.asset_strategy}"
-    puts "Fingerprinting: #{Solidstats.asset_fingerprinting?}"
-    puts "Asset Prefix: #{Solidstats.asset_prefix}"
-
-    puts "\nPrecompiled Assets:"
-    Solidstats::AssetManifest.assets_for_environment.each do |asset|
-      puts "  • #{asset}"
-    end
-
-    if Rails.application.config.respond_to?(:assets)
-      puts "\nAsset Paths:"
-      Rails.application.config.assets.paths.select { |p| p.include?("solidstats") }.each do |path|
-        puts "  • #{path}"
-      end
-    end
-  end
-
-  desc "Test asset compilation"
-  task compile_assets: :environment do
-    puts "🔧 Testing asset compilation..."
-
-    begin
-      test_assets = [ "solidstats/application.css", "solidstats/application.js" ]
-
-      if Rails.application.config.respond_to?(:assets)
-        manifest = Rails.application.assets
-
-        # Check if we're using Propshaft (Rails 7+) or Sprockets
-        if manifest.respond_to?(:find_asset)
-          # Sprockets
-          test_assets.each do |asset|
-            if manifest.find_asset(asset)
-              puts "✅ #{asset} - found and compilable (Sprockets)"
-            else
-              puts "❌ #{asset} - not found (Sprockets)"
-            end
-          end
-        elsif manifest.respond_to?(:load_path) && manifest.load_path.respond_to?(:find)
-          # Propshaft
-          test_assets.each do |asset|
-            if manifest.load_path.find(asset)
-              puts "✅ #{asset} - found and compilable (Propshaft)"
-            else
-              puts "❌ #{asset} - not found (Propshaft)"
-            end
-          end
-        else
-          # Unknown asset pipeline
-          puts "⚠️  Unknown asset pipeline type: #{manifest.class}"
-          puts "Available methods: #{manifest.methods.grep(/find/).join(', ')}"
-        end
-      else
-        puts "⚠️  No asset pipeline detected"
-      end
-
-      puts "✅ Asset compilation test complete"
-
-    rescue => e
-      puts "❌ Asset compilation failed: #{e.message}"
-      puts "Asset pipeline class: #{Rails.application.assets.class}" if Rails.application.respond_to?(:assets)
-      exit 1
-    end
-  end
-end