solidstats 1.1.0 → 2.0.0

data/app/services/solidstats/gem_metadata/fetcher_service.rb

@@ -0,0 +1,136 @@
+require "net/http"
+
+module Solidstats
+  module GemMetadata
+    class FetcherService
+      GemMeta = Struct.new(:name, :version, :current_version, :released, :info, :runtime, keyword_init: true)
+
+      def self.call(gem_names = nil, force_refresh = false)
+        new.call(gem_names, force_refresh)
+      end
+
+      def call(gem_names = nil, force_refresh = false)
+        gem_names = get_gem_names(gem_names)
+        fetch_metadata(gem_names, force_refresh)
+      end
+
+      private
+
+      def get_gem_names(gem_names)
+        return gem_names if gem_names.present?
+
+        gemfile_lock = Rails.root.join("Gemfile.lock")
+        return [] unless File.exist?(gemfile_lock)
+
+        lockfile = File.read(gemfile_lock)
+        parser = Bundler::LockfileParser.new(lockfile)
+        parser.specs.map(&:name)
+      end
+
+      def get_current_versions
+        gemfile_lock = Rails.root.join("Gemfile.lock")
+        return {} unless File.exist?(gemfile_lock)
+
+        lockfile = File.read(gemfile_lock)
+        parser = Bundler::LockfileParser.new(lockfile)
+
+        parser.specs.each_with_object({}) do |spec, versions|
+          versions[spec.name] = spec.version.to_s
+        end
+      end
+
+      def fetch_metadata(gem_names, force_refresh)
+        current_versions = get_current_versions
+
+        gem_names.map do |name|
+          fetch_gem_data(name, current_versions[name], force_refresh)
+        end
+      end
+
+      def fetch_gem_data(name, current_version, force_refresh)
+        cached_data = fetch_from_cache(name) unless force_refresh
+
+        if cached_data
+          # Update current version if it changed since caching
+          if current_version && cached_data.current_version != current_version
+            cached_data.current_version = current_version
+            cache_data(name, cached_data)
+          end
+          return cached_data
+        end
+
+        begin
+          data = fetch_from_api(name)
+          meta = GemMeta.new(
+            name: data["name"],
+            version: data["version"],
+            current_version: current_version,
+            released: data["version_created_at"] ? Time.parse(data["version_created_at"]) : nil,
+            info: data["info"],
+            runtime: data["dependencies"] && data["dependencies"]["runtime"] || []
+          )
+          cache_data(name, meta)
+          meta
+        rescue => e
+          Rails.logger.error("Failed to fetch gem metadata for #{name}: #{e.message}")
+          GemMeta.new(name: name, current_version: current_version, info: "(API unavailable)")
+        end
+      end
+
+      def fetch_from_api(name)
+        uri = URI.parse("https://rubygems.org/api/v1/gems/#{name}.json")
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = true
+        http.open_timeout = 5
+        http.read_timeout = 5
+
+        response = http.get(uri.request_uri)
+
+        if response.code == "200"
+          JSON.parse(response.body)
+        else
+          raise "API request failed with status #{response.code}"
+        end
+      end
+
+      def fetch_from_cache(name)
+        cache_file = cache_path(name)
+        return nil unless File.exist?(cache_file)
+
+        data = JSON.parse(File.read(cache_file))
+        cache_time = File.mtime(cache_file)
+
+        # Return nil if cache is older than 24 hours
+        return nil if Time.now - cache_time > 24.hours
+
+        GemMeta.new(
+          name: data["name"],
+          version: data["version"],
+          current_version: data["current_version"],
+          released: data["released"] ? Time.parse(data["released"]) : nil,
+          info: data["info"],
+          runtime: data["runtime"] || []
+        )
+      end
+
+      def cache_data(name, meta)
+        FileUtils.mkdir_p(File.dirname(cache_path(name)))
+
+        data = {
+          "name" => meta.name,
+          "version" => meta.version,
+          "current_version" => meta.current_version,
+          "released" => meta.released&.iso8601,
+          "info" => meta.info,
+          "runtime" => meta.runtime
+        }
+
+        File.write(cache_path(name), data.to_json)
+      end
+
+      def cache_path(name)
+        Rails.root.join("tmp", "cache", "gem_metadata", "#{name}.json")
+      end
+    end
+  end
+end

data/app/services/solidstats/log_size_monitor_service.rb

@@ -6,7 +6,7 @@ module Solidstats
     def collect_data
       log_files = scan_log_directory
       total_size_bytes = log_files.sum { |file| file[:size_bytes] }
-      
+
       # Create aggregated data
       {
         log_dir_path: log_directory,
@@ -24,11 +24,11 @@ module Solidstats
         if filename.present?
           # Truncate specific log file
           # Ensure filename has .log extension
-          filename = "#{filename}.log" unless filename.end_with?('.log')
-          
+          filename = "#{filename}.log" unless filename.end_with?(".log")
+
           file_path = File.join(log_directory, filename)
           if File.exist?(file_path)
-            File.open(file_path, 'w') { |f| f.truncate(0) }
+            File.open(file_path, "w") { |f| f.truncate(0) }
             { success: true, message: "Log file '#{filename}' truncated successfully" }
           else
             { success: false, message: "Log file '#{filename}' not found" }
@@ -36,7 +36,7 @@ module Solidstats
         else
           # Truncate all log files
           scan_log_directory.each do |log_file|
-            File.open(log_file[:path], 'w') { |f| f.truncate(0) }
+            File.open(log_file[:path], "w") { |f| f.truncate(0) }
           end
           { success: true, message: "All log files truncated successfully" }
         end
@@ -50,16 +50,16 @@ module Solidstats
     def log_directory
       Rails.root.join("log").to_s
     end
-    
+
     def scan_log_directory
       log_files = []
-      
+
       # Get all files in the log directory
       Dir.glob(File.join(log_directory, "*.log")).each do |file_path|
         if File.file?(file_path)
           size_bytes = File.size(file_path)
           filename = File.basename(file_path)
-          
+
           log_files << {
             filename: filename,
             path: file_path,
@@ -70,7 +70,7 @@ module Solidstats
           }
         end
       end
-      
+
       # Sort by size (largest first)
       log_files.sort_by { |file| -file[:size_bytes] }
     end
@@ -81,7 +81,7 @@ module Solidstats
 
     def calculate_status(size_bytes)
       size_mb = bytes_to_mb(size_bytes)
-      
+
       if size_mb >= DANGER_THRESHOLD
         :danger
       elsif size_mb >= WARNING_THRESHOLD

data/app/views/layouts/solidstats/application.html.erb

@@ -7,7 +7,8 @@
 
   <%= yield :head %>
 
-  <%= stylesheet_link_tag    "solidstats/application", media: "all" %>
+  <%= solidstats_styles %>
+  <%= solidstats_scripts %>
 </head>
 <body>