active_storage_dashboard 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 3c7c2bae3dc09def165c1871bf8e5d5636e6a1fe51f3a3c74c076dc40e383aa3
+  data.tar.gz: 6b0fdf2d5563fbf5d48848cc8322338bde7e916f3d180357c5b31d551626746e
+SHA512:
+  metadata.gz: 3b402f97201e4e87e2c1bc67130f541cb6907222f2e0e271a61aa098540b108d4a986a2186b4ca0bb245997ac9b097a534bf3da473037cb216361033232dd626
+  data.tar.gz: e8dd05436410c27994704a8ef3d030ee909d931fa8758416c33ae73eb37e631a7799b0a4a822339069c5205070dc6eeb5e34adb9df233a5f57a455cb4f7da972

data/README.md

@@ -0,0 +1,91 @@
+# 🚀 Active Storage Dashboard
+
+A beautiful Rails engine that provides a sleek, modern dashboard for monitoring and inspecting Active Storage data in your Rails application.
+
+![Active Storage Dashboard Screenshot](https://github.com/giovapanasiti/active_storage_dashboard/blob/main/screenshots/dashboard.png)
+
+
+## ✨ Features
+
+- 📊 Overview of Active Storage usage statistics
+- 🔍 Browse and inspect blobs, attachments and variant records
+- 📝 View metadata, file details, and relationships
+- 🎨 Modern, responsive UI with animations
+- 🚫 No external dependencies (vanilla JavaScript and CSS)
+
+## 📥 Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'active_storage_dashboard'
+```
+
+And then execute:
+
+```bash
+$ bundle
+```
+
+## 🔧 Usage
+
+Mount the engine in your `config/routes.rb` file:
+
+```ruby
+Rails.application.routes.draw do
+  # IMPORTANT: Make sure the mount path does not contain any special characters
+  # Use a simple path like '/active-storage-dashboard' or '/storage-dashboard'
+  # This is crucial for proper URL generation
+  mount ActiveStorageDashboard::Engine, at: "/active-storage-dashboard"
+end
+```
+
+Then visit `/active-storage-dashboard` in your browser to see the beautiful dashboard.
+
+### 📁 File Downloads
+
+The dashboard provides direct file download capabilities from both the list and detail views. Simply click on the download button to get your files.
+
+### 📸 Screenshots
+
+<details>
+  <summary>Click to see more screenshots</summary>
+  
+  #### Dashboard Overview
+  ![Dashboard Overview](https://github.com/giovapanasiti/active_storage_dashboard/blob/main/screenshots/dashboard.png)
+  
+  #### Blob Details
+  ![Blob Details](https://github.com/giovapanasiti/active_storage_dashboard/blob/main/screenshots/blob-details.png)
+  
+  #### Files Gallery
+  ![Files Gallery](https://github.com/giovapanasiti/active_storage_dashboard/blob/main/screenshots/files-gallery.png)
+  
+</details>
+
+## 🔒 Security Considerations
+
+This dashboard provides access to all Active Storage data. Consider adding authentication before using in production:
+
+```ruby
+# config/routes.rb
+authenticate :user, -> (user) { user.admin? } do
+  mount ActiveStorageDashboard::Engine, at: "/active-storage-dashboard"
+end
+```
+
+or with devise:
+
+```ruby
+constraints lambda { |req| req.session[:user_id].present? || (req.env['warden'] && req.env['warden'].user(:user)) } do
+  mount ActiveStorageDashboard::Engine, at: "/active-storage-dashboard"
+end
+```
+
+
+## 🤝 Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/giovapanasiti/active-storage-dashboard.
+
+## 📝 License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT). 

data/Rakefile

@@ -0,0 +1,17 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'ActiveStorageDashboard'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.md')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+require 'bundler/gem_tasks' 

data/app/controllers/active_storage_dashboard/application_controller.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module ActiveStorageDashboard
+  class ApplicationController < ActionController::Base
+    protect_from_forgery with: :exception
+    
+    # Simple pagination without external dependencies
+    helper_method :paginate
+
+    def paginate(scope, per_page = 20)
+      @page = [params[:page].to_i, 1].max
+      scope.limit(per_page).offset((@page - 1) * per_page)
+    end
+  end
+end 

data/app/controllers/active_storage_dashboard/attachments_controller.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module ActiveStorageDashboard
+  class AttachmentsController < ApplicationController
+    def index
+      @attachments = paginate(ActiveStorage::Attachment.order(created_at: :desc))
+      @total_count = ActiveStorage::Attachment.count
+    end
+
+    def show
+      @attachment = ActiveStorage::Attachment.find(params[:id])
+      @blob = @attachment.blob
+    end
+    
+    def download
+      @attachment = ActiveStorage::Attachment.find(params[:id])
+      @blob = @attachment.blob
+      
+      # Pass along the disposition parameter if present
+      if params[:disposition].present?
+        redirect_to download_blob_path(@blob, disposition: params[:disposition])
+      else
+        redirect_to download_blob_path(@blob)
+      end
+    end
+  end
+end 

data/app/controllers/active_storage_dashboard/blobs_controller.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module ActiveStorageDashboard
+  class BlobsController < ApplicationController
+    def index
+      @blobs = paginate(ActiveStorage::Blob.order(created_at: :desc))
+      @total_count = ActiveStorage::Blob.count
+    end
+
+    def show
+      @blob = ActiveStorage::Blob.find(params[:id])
+      @attachments = @blob.attachments
+      @variant_records = defined?(ActiveStorage::VariantRecord) ? @blob.variant_records : []
+    end
+    
+    def download
+      @blob = ActiveStorage::Blob.find(params[:id])
+      
+      # Determine the disposition (inline for preview, attachment for download)
+      # Params can be route params or query params
+      disposition = params[:disposition] || 'attachment'
+      
+      # Different approaches depending on Rails version
+      if @blob.respond_to?(:open)
+        # Rails 6.0+: Use the open method to get the file
+        begin
+          @blob.open do |file|
+            send_data file.read, 
+                      filename: @blob.filename.to_s, 
+                      type: @blob.content_type || 'application/octet-stream', 
+                      disposition: disposition
+          end
+        rescue => e
+          Rails.logger.error("Failed to download blob: #{e.message}")
+          redirect_to blob_path(@blob), alert: "Download failed: #{e.message}"
+        end
+      elsif @blob.respond_to?(:download)
+        # Alternative approach: Use the download method
+        begin
+          send_data @blob.download, 
+                    filename: @blob.filename.to_s, 
+                    type: @blob.content_type || 'application/octet-stream', 
+                    disposition: disposition
+        rescue => e
+          Rails.logger.error("Failed to download blob: #{e.message}")
+          redirect_to blob_path(@blob), alert: "Download failed: #{e.message}"
+        end
+      else
+        # Fallback: Redirect to main app blob path
+        disposition_param = disposition == 'inline' ? { disposition: 'inline' } : { disposition: 'attachment' }
+        redirect_to main_app.rails_blob_path(@blob, disposition_param)
+      end
+    end
+  end
+end 

data/app/controllers/active_storage_dashboard/dashboard_controller.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+module ActiveStorageDashboard
+  class DashboardController < ApplicationController
+    def index
+      @blobs_count = ActiveStorage::Blob.count
+      @attachments_count = ActiveStorage::Attachment.count
+      @variant_records_count = defined?(ActiveStorage::VariantRecord) ? ActiveStorage::VariantRecord.count : 0
+      
+      @total_storage = ActiveStorage::Blob.sum(:byte_size)
+      @content_types = ActiveStorage::Blob.group(:content_type).count.sort_by { |_, count| -count }.first(5)
+      
+      @recent_blobs = ActiveStorage::Blob.order(created_at: :desc).limit(5)
+      
+      # Find largest blob
+      @largest_blob = ActiveStorage::Blob.order(byte_size: :desc).first
+      
+      # Initialize empty hash for the timeline chart
+      @blobs_by_month = {}
+      
+      begin
+        load_timeline_data
+      rescue => e
+        # If everything fails, generate sample data
+        Rails.logger.error "Error in timeline chart preparation: #{e.message}"
+        generate_sample_timeline_data
+      end
+    end
+    
+    private
+    
+    def load_timeline_data
+      # Get all blobs created in the last year
+      start_date = 1.year.ago.beginning_of_month
+      
+      # First try with ActiveRecord
+      begin
+        blobs_with_dates = ActiveStorage::Blob
+          .where('created_at >= ?', start_date)
+          .pluck(:created_at)
+        
+        # Group by year-month manually
+        month_counts = Hash.new(0)
+        blobs_with_dates.each do |date|
+          month_key = date.strftime('%Y-%m')
+          month_counts[month_key] += 1
+        end
+        
+        # Sort by month
+        @blobs_by_month = month_counts.sort.to_h
+        
+        # If we didn't get any data and there are blobs, try the adapter-specific methods
+        if @blobs_by_month.empty? && ActiveStorage::Blob.count > 0
+          adapter_specific_timeline_data
+        end
+      rescue => e
+        # If ActiveRecord method fails, try adapter-specific methods
+        Rails.logger.error "Error using ActiveRecord for timeline: #{e.message}"
+        adapter_specific_timeline_data
+      end
+    end
+    
+    def adapter_specific_timeline_data
+      adapter = ActiveRecord::Base.connection.adapter_name.downcase
+      table_name = ActiveStorage::Blob.table_name
+      
+      begin
+        # Different approach for different database adapters
+        if adapter.include?('sqlite')
+          # SQLite
+          result = ActiveRecord::Base.connection.execute(
+            "SELECT strftime('%Y-%m', created_at) as month, COUNT(*) as count " +
+            "FROM #{table_name} GROUP BY strftime('%Y-%m', created_at) " +
+            "ORDER BY month LIMIT 12"
+          )
+          
+          result.each do |row|
+            @blobs_by_month[row['month']] = row['count']
+          end
+        elsif adapter.include?('mysql')
+          # MySQL
+          result = ActiveRecord::Base.connection.execute(
+            "SELECT DATE_FORMAT(created_at, '%Y-%m') as month, COUNT(*) as count " +
+            "FROM #{table_name} GROUP BY DATE_FORMAT(created_at, '%Y-%m') " +
+            "ORDER BY month LIMIT 12"
+          )
+          
+          result.each do |row|
+            month_key = row[0] || row['month'] # Handle different result formats
+            count = row[1] || row['count']
+            @blobs_by_month[month_key] = count
+          end
+        else
+          # PostgreSQL or others
+          result = ActiveRecord::Base.connection.execute(
+            "SELECT TO_CHAR(created_at, 'YYYY-MM') as month, COUNT(*) as count " +
+            "FROM #{table_name} GROUP BY TO_CHAR(created_at, 'YYYY-MM') " +
+            "ORDER BY month LIMIT 12"
+          )
+          
+          result.each do |row|
+            month_key = row['month']
+            count = row['count']
+            @blobs_by_month[month_key] = count if month_key && count
+          end
+        end
+      rescue => e
+        # If database-specific approach fails, use sample data
+        Rails.logger.error "Error using #{adapter} for timeline: #{e.message}"
+        generate_sample_timeline_data
+      end
+    end
+    
+    def generate_sample_timeline_data
+      # Generate sample data for last 6 months if we can't query the database
+      today = Date.today
+      6.times do |i|
+        month = (today - i.months).strftime('%Y-%m')
+        @blobs_by_month[month] = rand(1..20) # Random count between 1-20
+      end
+    end
+  end
+end 

data/app/controllers/active_storage_dashboard/variant_records_controller.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module ActiveStorageDashboard
+  class VariantRecordsController < ApplicationController
+    def index
+      if defined?(ActiveStorage::VariantRecord)
+        @variant_records = paginate(ActiveStorage::VariantRecord.order(id: :desc))
+        @total_count = ActiveStorage::VariantRecord.count
+      else
+        @variant_records = []
+        @total_count = 0
+      end
+    end
+
+    def show
+      if defined?(ActiveStorage::VariantRecord)
+        @variant_record = ActiveStorage::VariantRecord.find(params[:id])
+        @blob = @variant_record.blob
+      else
+        redirect_to root_path, alert: "Variant Records are not available in this Rails version"
+      end
+    end
+  end
+end 

data/app/helpers/active_storage_dashboard/application_helper.rb

@@ -0,0 +1,289 @@
+# frozen_string_literal: true
+
+module ActiveStorageDashboard
+  module ApplicationHelper
+    # Include Rails URL helpers to easily generate blob URLs
+    include Rails.application.routes.url_helpers
+    
+    # Helper to get the main app's routes
+    def main_app
+      Rails.application.class.routes.url_helpers
+    end
+    
+    # Helper to generate a URL for direct blob viewing (for embedding media)
+    def rails_blob_url(blob, disposition: nil)
+      # For media embedding, we need a reliable URL to the blob
+      if defined?(request) && request.present?
+        # Get the proper host from the request
+        host = request.base_url
+        
+        # Different approaches depending on Rails version
+        if Rails.gem_version >= Gem::Version.new('6.1') && Rails.application.routes.url_helpers.respond_to?(:rails_storage_proxy_path)
+          # Rails 6.1+ uses proxy approach
+          return host + Rails.application.routes.url_helpers.rails_storage_proxy_path(blob, disposition: disposition)
+        elsif Rails.application.routes.url_helpers.respond_to?(:rails_service_blob_path)
+          # Rails 5.2-6.0
+          return host + Rails.application.routes.url_helpers.rails_service_blob_path(blob.key, disposition: disposition)
+        elsif Rails.application.routes.url_helpers.respond_to?(:rails_blob_path)
+          # Another approach
+          return host + Rails.application.routes.url_helpers.rails_blob_path(blob, disposition: disposition)
+        end
+      end
+      
+      # Fallback to direct service URL
+      if blob.respond_to?(:url)
+        return blob.url(disposition: disposition)
+      elsif blob.respond_to?(:service_url)
+        return blob.service_url(disposition: disposition)
+      end
+      
+      # Last resort - return path to download action in our engine
+      active_storage_dashboard.download_blob_path(blob)
+    end
+    
+    def pagination_links(total_count, per_page = 20)
+      return if total_count <= per_page
+      
+      total_pages = (total_count.to_f / per_page).ceil
+      current_page = [@page.to_i, 1].max
+      
+      content_tag :div, class: 'pagination' do
+        html = []
+        
+        if current_page > 1
+          html << link_to('« Previous', url_for(page: current_page - 1), class: 'pagination-link')
+        else
+          html << content_tag(:span, '« Previous', class: 'pagination-link disabled')
+        end
+        
+        # Show window of pages
+        window_size = 5
+        window_start = [1, current_page - (window_size / 2)].max
+        window_end = [total_pages, window_start + window_size - 1].min
+        
+        # Adjust window_start if we're at the end
+        window_start = [1, window_end - window_size + 1].max
+        
+        # First page
+        if window_start > 1
+          html << link_to('1', url_for(page: 1), class: 'pagination-link')
+          html << content_tag(:span, '...', class: 'pagination-ellipsis') if window_start > 2
+        end
+        
+        # Page window
+        (window_start..window_end).each do |page|
+          if page == current_page
+            html << content_tag(:span, page, class: 'pagination-link current')
+          else
+            html << link_to(page, url_for(page: page), class: 'pagination-link')
+          end
+        end
+        
+        # Last page
+        if window_end < total_pages
+          html << content_tag(:span, '...', class: 'pagination-ellipsis') if window_end < total_pages - 1
+          html << link_to(total_pages, url_for(page: total_pages), class: 'pagination-link')
+        end
+        
+        if current_page < total_pages
+          html << link_to('Next »', url_for(page: current_page + 1), class: 'pagination-link')
+        else
+          html << content_tag(:span, 'Next »', class: 'pagination-link disabled')
+        end
+        
+        safe_join(html)
+      end
+    end
+    
+    def format_bytes(bytes)
+      return '0 B' if bytes.nil? || bytes == 0
+      
+      units = ['B', 'KB', 'MB', 'GB', 'TB', 'PB']
+      exponent = (Math.log(bytes) / Math.log(1024)).to_i
+      exponent = [exponent, units.size - 1].min
+      
+      converted = bytes.to_f / (1024 ** exponent)
+      "#{format('%.2f', converted)} #{units[exponent]}"
+    end
+    
+    # Check if a blob can be previewed
+    def previewable_blob?(blob)
+      return false unless blob.present?
+      
+      # Check for representable content based on content type
+      content_type = blob.content_type
+      return false unless content_type.present?
+      
+      image_types = ['image/jpeg', 'image/png', 'image/gif', 'image/webp']
+      return true if image_types.include?(content_type)
+      
+      # Check for previewable content in Rails 6+ using Active Storage's previewable method
+      if defined?(ActiveStorage::Blob.new.preview) && 
+         blob.respond_to?(:previewable?) && 
+         blob.previewable?
+        return true
+      end
+      
+      false
+    end
+    
+    # Generate preview HTML for a blob
+    def blob_preview(blob)
+      return "" unless blob.present?
+      
+      content_type = blob.content_type
+      
+      if content_type&.start_with?('image/')
+        url = Rails.application.routes.url_helpers.rails_blob_url(blob, disposition: "inline", only_path: true)
+        return image_tag(url, alt: blob.filename)
+      elsif defined?(ActiveStorage::Blob.new.preview) && 
+            blob.respond_to?(:previewable?) && 
+            blob.previewable?
+        # This will work in Rails 6+ with proper preview handlers configured
+        begin
+          url = Rails.application.routes.url_helpers.rails_blob_url(
+            blob.preview(resize: "300x300").processed.image, 
+            disposition: "inline", 
+            only_path: true
+          )
+          return image_tag(url, alt: blob.filename, class: "preview-image")
+        rescue => e
+          # Fallback if preview fails for any reason
+          Rails.logger.error("Preview generation failed: #{e.message}")
+          return content_tag(:div, "Preview not available", class: "preview-error")
+        end
+      end
+      
+      return content_tag(:div, "No preview available", class: "no-preview")
+    end
+    
+    # Check if an attachment can be previewed
+    def previewable_attachment?(attachment)
+      return false unless attachment&.blob&.present?
+      
+      previewable_blob?(attachment.blob)
+    end
+    
+    # Generate preview HTML for an attachment
+    def attachment_preview(attachment)
+      return "" unless attachment&.blob&.present?
+      
+      blob_preview(attachment.blob)
+    end
+    
+    # Helper to generate a download URL for a blob
+    def download_blob_url(blob)
+      begin
+        # Try simple direct download URL first using the blob's service URL
+        # This is often the most reliable method
+        if blob.respond_to?(:service_url)
+          return blob.service_url(disposition: "attachment", filename: blob.filename.to_s)
+        end
+        
+        # If we're in a Rails 6.1+ app, use the direct representation URL
+        if Rails.gem_version >= Gem::Version.new('6.1') &&
+           blob.respond_to?(:representation) &&
+           Rails.application.routes.url_helpers.respond_to?(:rails_blob_representation_url)
+          
+          # Force a download by using the blob directly
+          return Rails.application.routes.url_helpers.rails_blob_url(blob, disposition: "attachment")
+        end
+        
+        # For Rails 6.0, use standard blob URL approach
+        if Rails.application.routes.url_helpers.respond_to?(:rails_blob_url)
+          host_options = {}
+          
+          # Make sure we have a host set for URL generation
+          if defined?(request) && request.present?
+            host_options[:host] = request.host
+            host_options[:port] = request.port if request.port != 80 && request.port != 443
+            host_options[:protocol] = request.protocol.sub('://', '')
+          elsif Rails.application.config.action_controller.default_url_options[:host].present?
+            host_options = Rails.application.config.action_controller.default_url_options
+          else
+            # Fallback to localhost for development
+            host_options[:host] = 'localhost'
+            host_options[:port] = 3000
+            host_options[:protocol] = 'http'
+          end
+          
+          # Ensure disposition is set for attachment download
+          return Rails.application.routes.url_helpers.rails_blob_url(blob, **host_options, disposition: "attachment")
+        end
+        
+        # For Rails 5.2
+        if Rails.application.routes.url_helpers.respond_to?(:rails_service_blob_url)
+          host_options = {}
+          if defined?(request) && request.present?
+            host_options[:host] = request.host
+            host_options[:port] = request.port if request.port != 80 && request.port != 443
+            host_options[:protocol] = request.protocol.sub('://', '')
+          end
+          return Rails.application.routes.url_helpers.rails_service_blob_url(blob.key, **host_options, disposition: "attachment")
+        end
+        
+        # If all else fails, use the direct download path (for development)
+        if Rails.application.routes.url_helpers.respond_to?(:rails_blob_path)
+          return Rails.application.routes.url_helpers.rails_blob_path(blob, disposition: "attachment")
+        end
+        
+        Rails.logger.error("Could not determine download URL for blob #{blob.id}")
+        return "#"
+      rescue => e
+        Rails.logger.error("Error generating download URL: #{e.message}")
+        Rails.logger.error(e.backtrace.join("\n"))
+        return "#"
+      end
+    end
+
+    # Ensure we're properly using the engine routes
+    def active_storage_dashboard
+      ActiveStorageDashboard::Engine.routes.url_helpers
+    end
+
+    # Fix URL generation by explicitly using the engine routes
+    def download_attachment_path(attachment, options = {})
+      if options[:disposition].present?
+        # For paths with parameters, we need to construct the URL manually
+        disposition = options[:disposition]
+        active_storage_dashboard.download_attachment_path(attachment, disposition: disposition)
+      else
+        active_storage_dashboard.download_attachment_path(attachment)
+      end
+    end
+
+    def download_blob_path(blob, options = {})
+      if options[:disposition].present?
+        # For paths with parameters, we need to construct the URL manually
+        disposition = options[:disposition]
+        active_storage_dashboard.download_blob_path(blob, disposition: disposition)
+      else
+        active_storage_dashboard.download_blob_path(blob)
+      end
+    end
+
+    def attachment_path(attachment)
+      active_storage_dashboard.attachment_path(attachment)
+    end
+
+    def blob_path(blob)
+      active_storage_dashboard.blob_path(blob)
+    end
+
+    def attachments_path
+      active_storage_dashboard.attachments_path
+    end
+
+    def blobs_path
+      active_storage_dashboard.blobs_path
+    end
+
+    def variant_records_path
+      active_storage_dashboard.variant_records_path
+    end
+
+    def variant_record_path(variant_record)
+      active_storage_dashboard.variant_record_path(variant_record)
+    end
+  end
+end