solidstats 2.0.0 → 3.0.0

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

@@ -1,136 +0,0 @@
-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/todo_service.rb

@@ -1,114 +0,0 @@
-# frozen_string_literal: true
-
-module Solidstats
-  # Service to collect and process TODO items from codebase
-  class TodoService < DataCollectorService
-    # Initialize with default cache settings for TODO items
-    def initialize
-      super(Rails.root.join("tmp", "solidstats_todos.json"))
-    end
-
-    # Generate a summary for the dashboard display
-    # @return [Hash] Summary information with counts and status
-    def summary
-      todos = fetch
-      return { count: 0, status: "success", message: "No TODO items found" } if todos.nil? || todos.empty?
-
-      stats = calculate_stats(todos)
-
-      {
-        count: todos.count,
-        status: determine_status(todos),
-        message: generate_message(todos.count),
-        by_type: stats[:by_type],
-        hotspots: stats[:hotspots]
-      }
-    end
-
-    private
-
-    # Calculate statistics for the TODO items
-    # @param todos [Array] List of TODO items
-    # @return [Hash] Statistics about the TODO items
-    def calculate_stats(todos)
-      stats = {
-        by_type: {
-          "TODO" => todos.count { |t| (t[:type] || t["type"]) == "TODO" },
-          "FIXME" => todos.count { |t| (t[:type] || t["type"]) == "FIXME" },
-          "HACK" => todos.count { |t| (t[:type] || t["type"]) == "HACK" }
-        },
-        by_file: {}
-      }
-
-      # Group by file path
-      todos.each do |todo|
-        file_path = todo[:file] || todo["file"]
-        stats[:by_file][file_path] ||= 0
-        stats[:by_file][file_path] += 1
-      end
-
-      # Find files with most TODOs (top 5)
-      stats[:hotspots] = stats[:by_file].sort_by { |_, count| -count }
-                                       .first(5)
-                                       .to_h
-
-      stats
-    end
-
-    # Determine the status indicator based on TODO items
-    # @param todos [Array] List of TODO items
-    # @return [String] Status indicator (success, warning, or danger)
-    def determine_status(todos)
-      fixme_count = todos.count { |t| t[:type] == "FIXME" }
-      hack_count = todos.count { |t| t[:type] == "HACK" }
-
-      if hack_count > 0
-        "danger"
-      elsif fixme_count > 0
-        "warning"
-      elsif todos.count > 10
-        "warning"
-      else
-        "success"
-      end
-    end
-
-    # Generate a status message based on TODO count
-    # @param count [Integer] Number of TODOs
-    # @return [String] Human-readable status message
-    def generate_message(count)
-      "#{count} #{count == 1 ? 'item' : 'items'} found"
-    end
-
-    # Collect fresh TODO data by scanning the codebase
-    # @return [Array] List of TODO items found
-    def collect_data
-      todos = []
-      raw_output = `grep -r -n -E "(TODO|FIXME|HACK|todo|fixme|hack)" app lib`.split("\n")
-
-      raw_output.each do |line|
-        if line =~ /^(.+):(\d+):(.+)$/
-          file = $1
-          line_num = $2
-          content = $3
-
-          # Match only exact lowercase or uppercase variants
-          type_match = content.match(/(TODO|FIXME|HACK|todo|fixme|hack)/)
-          if type_match
-            # Convert to uppercase for consistency
-            type = type_match.to_s.upcase
-
-            todos << {
-              file: file,
-              line: line_num.to_i,
-              content: content.strip,
-              type: type
-            }
-          end
-        end
-      end
-
-      todos
-    end
-  end
-end