Merge pull request #56 from zerochae/refactor/oop-structure-improvement

refactor: convert to middleclass OOP architecture and improve code organization

Author: zerochae

doc/endpoint.txt

@@ -294,7 +294,8 @@ endpoint.nvim uses a modern Object-Oriented architecture with:
   • Framework: Base class for all framework implementations
   • Parser: Handles endpoint parsing specific to each framework
   • Detector: Unified detection system (integrated into Framework)
-  • EndpointManager: Manages all registered frameworks
+  • Endpoint: Main orchestrator managing all components
+  • FrameworkRegistry: Manages framework registration and detection
 
 Framework Detection:~
 
@@ -364,7 +365,7 @@ The plugin uses a modern OOP architecture. Each framework consists of:
 1. Framework Class (inherits from base Framework)
 2. Parser Class (inherits from base Parser)
 
-Framework classes must be registered in EndpointManager.lua.
+Framework classes are automatically registered in FrameworkRegistry.
 
 See wiki/Adding-New-Frameworks.md for detailed implementation guide.
 
@@ -389,7 +390,7 @@ A: Verify detection files exist:
    • Spring: pom.xml, build.gradle, or application config files
    • Rails: Gemfile, config/routes.rb, or app/controllers/
    • Express: package.json with express dependency
-   • Check EndpointManager registration for your framework
+   • Check FrameworkRegistry for your framework registration
 
 Q: Icons not displaying
 A: Ensure:
@@ -412,7 +413,7 @@ A: Consider:
 
 Debug Information:~
     View current config: `lua print(vim.inspect(require("endpoint").get_config()))`
-    Check framework detection: `lua print(vim.inspect(require("endpoint.manager.EndpointManager"):new():get_detected_frameworks()))`
+    Check framework detection: `lua print(vim.inspect(require("endpoint").detect_frameworks()))`
     Clear cache and retry: `:Endpoint ClearCache`
     Enable framework debugging: `lua vim.g.endpoint_debug = true`
 

lua/endpoint/manager/CacheManager.lua lua/endpoint/core/Cache.lualua/endpoint/manager/CacheManager.lua renamed to lua/endpoint/core/Cache.lua

@@ -1,33 +1,31 @@
----@class endpoint.CacheManager
-local CacheManager = {}
-CacheManager.__index = CacheManager
+local class = require "endpoint.lib.middleclass"
 
-function CacheManager:new()
-  local cache_instance = setmetatable({}, self)
-  cache_instance.cached_endpoints = {}
-  cache_instance.cache_timestamps = {}
-  cache_instance.cache_mode = "session" -- Will be set by EndpointManager
-  return cache_instance
+---@class endpoint.Cache
+local Cache = class "Cache"
+
+function Cache:initialize()
+  self.cached_endpoints = {}
+  self.cache_timestamps = {}
+  self.cache_mode = "session"
 end
 
-function CacheManager:set_mode(mode)
+function Cache:set_mode(mode)
   self.cache_mode = mode
 end
 
-function CacheManager:_get_cache_key(method)
+function Cache:_get_cache_key(method)
   return method or "all"
 end
 
-function CacheManager:_get_cache_dir()
+function Cache:_get_cache_dir()
   return vim.fn.stdpath "cache" .. "/endpoint.nvim"
 end
 
-function CacheManager:_get_project_hash()
-  -- Use current working directory name as simple project identifier
-  return vim.fn.fnamemodify(vim.fn.getcwd(), ":t"):gsub("[^%w]", "_")
+function Cache:_get_project_hash()
+  return (vim.fn.fnamemodify(vim.fn.getcwd(), ":t"):gsub("[^%w]", "_"))
 end
 
-function CacheManager:_get_cache_file_path(method)
+function Cache:_get_cache_file_path(method)
   local cache_dir = self:_get_cache_dir()
   local project_hash = self:_get_project_hash()
   local cache_key = self:_get_cache_key(method)
@@ -40,24 +38,24 @@ function CacheManager:_get_cache_file_path(method)
   end
 end
 
-function CacheManager:_ensure_cache_dir()
+function Cache:_ensure_cache_dir()
   local cache_dir = self:_get_cache_dir()
   if vim.fn.isdirectory(cache_dir) == 0 then
     vim.fn.mkdir(cache_dir, "p")
   end
 end
 
-function CacheManager:is_valid(method)
+function Cache:is_valid(method)
   if self.cache_mode == "persistent" then
     local loaded_data = self:_load_from_disk(method)
     return loaded_data ~= nil and #loaded_data > 0
   else
     local cache_key = self:_get_cache_key(method)
-    return self.cached_endpoints[cache_key] and #self.cached_endpoints[cache_key] > 0
+    return self.cached_endpoints[cache_key] ~= nil and #self.cached_endpoints[cache_key] > 0
   end
 end
 
-function CacheManager:get_endpoints(method)
+function Cache:get_endpoints(method)
   if self.cache_mode == "persistent" then
     local endpoints = self:_load_from_disk(method)
     return endpoints or {}
@@ -67,7 +65,7 @@ function CacheManager:get_endpoints(method)
   end
 end
 
-function CacheManager:save_endpoints(endpoints, method)
+function Cache:save_endpoints(endpoints, method)
   local cache_key = self:_get_cache_key(method)
 
   -- Always save to memory for session access
@@ -80,7 +78,7 @@ function CacheManager:save_endpoints(endpoints, method)
   end
 end
 
-function CacheManager:_save_to_disk(endpoints, method)
+function Cache:_save_to_disk(endpoints, method)
   local success, err = pcall(function()
     self:_ensure_cache_dir()
     local file_path = self:_get_cache_file_path(method)
@@ -104,7 +102,7 @@ function CacheManager:_save_to_disk(endpoints, method)
   end
 end
 
-function CacheManager:_serialize_table(tbl)
+function Cache:_serialize_table(tbl)
   if type(tbl) ~= "table" then
     if type(tbl) == "string" then
       return string.format("%q", tbl)
@@ -132,7 +130,7 @@ function CacheManager:_serialize_table(tbl)
   return table.concat(parts)
 end
 
-function CacheManager:_load_from_disk(method)
+function Cache:_load_from_disk(method)
   local success, result = pcall(function()
     local file_path = self:_get_cache_file_path(method)
 
@@ -158,7 +156,7 @@ function CacheManager:_load_from_disk(method)
   end
 end
 
-function CacheManager:clear()
+function Cache:clear()
   self.cached_endpoints = {}
   self.cache_timestamps = {}
 
@@ -168,7 +166,7 @@ function CacheManager:clear()
   end
 end
 
-function CacheManager:_clear_disk_cache()
+function Cache:_clear_disk_cache()
   local success, err = pcall(function()
     local cache_dir = self:_get_cache_dir()
     local project_hash = self:_get_project_hash()
@@ -194,7 +192,7 @@ function CacheManager:_clear_disk_cache()
   end
 end
 
-function CacheManager:get_stats()
+function Cache:get_stats()
   local total_endpoints = 0
   for _, endpoints in pairs(self.cached_endpoints) do
     total_endpoints = total_endpoints + #endpoints
@@ -208,5 +206,5 @@ function CacheManager:get_stats()
   }
 end
 
--- Export the CacheManager class for OOP usage
-return CacheManager
+-- Export the Cache class for OOP usage
+return Cache

lua/endpoint/core/Detector.lua

@@ -1,61 +1,34 @@
 local fs = require "endpoint.utils.fs"
+local class = require "endpoint.lib.middleclass"
 
 ---@class endpoint.Detector
-local Detector = {}
-Detector.__index = Detector
-
----Creates a new Detector instance with optional fields
-function Detector:new(detection_name, fields)
-  local detector = setmetatable({}, self)
-  detector.detection_name = detection_name or "unknown"
-
-  -- Set additional fields if provided
-  if fields then
-    for key, value in pairs(fields) do
-      detector[key] = value
-    end
-  end
-
-  return detector
-end
+local Detector = class "Detector"
 
----Creates a new Detector for dependency-based detection
-function Detector:new_dependency_detector(required_dependencies, manifest_files, detection_name)
-  local detector = self:new(detection_name or "dependency_based_detection", {
-    required_dependencies = required_dependencies or {},
-    manifest_files = manifest_files or {},
-  })
-  return detector
+function Detector:initialize(required_dependencies, manifest_files, detection_name)
+  self.detection_name = detection_name or "dependency_detection"
+  self.required_dependencies = required_dependencies or {}
+  self.manifest_files = manifest_files or {}
 end
 
----Detects if any of the required dependencies are present in manifest files
 function Detector:is_target_detected()
-  -- If we have dependencies and manifest files, use dependency detection
-  if self.required_dependencies and self.manifest_files then
-    -- First check root level manifest files
-    for _, manifest_file_path in ipairs(self.manifest_files) do
-      if fs.has_file { manifest_file_path } then
-        if self:_check_manifest_file_for_dependencies(manifest_file_path) then
-          return true
-        end
+  for _, manifest_file_path in ipairs(self.manifest_files) do
+    if fs.has_file { manifest_file_path } then
+      if self:_check_manifest_file_for_dependencies(manifest_file_path) then
+        return true
       end
     end
+  end
 
-    -- For Maven projects, also check submodules
-    if self:_should_check_submodules() then
-      local submodule_manifest_files = self:_find_submodule_manifest_files()
-      for _, submodule_manifest_path in ipairs(submodule_manifest_files) do
-        if self:_check_manifest_file_for_dependencies(submodule_manifest_path) then
-          return true
-        end
+  if self:_should_check_submodules() then
+    local submodule_manifest_files = self:_find_submodule_manifest_files()
+    for _, submodule_manifest_path in ipairs(submodule_manifest_files) do
+      if self:_check_manifest_file_for_dependencies(submodule_manifest_path) then
+        return true
       end
     end
-
-    return false
   end
 
-  -- Default implementation for subclasses
-  error("is_target_detected() must be implemented by subclass: " .. self.detection_name)
+  return false
 end
 
 ---Checks a specific manifest file for required dependencies
@@ -74,89 +47,66 @@ function Detector:get_name()
   return self.detection_name
 end
 
----Gets detailed information about what was detected
 function Detector:get_detection_details()
   if not self:is_target_detected() then
     return nil
   end
 
-  local base_details = {
-    detector_name = self.detection_name,
-    detected_at = os.time(),
-    is_detected = true,
-  }
+  local detected_dependencies = {}
+  local searched_manifest_files = {}
+
+  for _, manifest_file_path in ipairs(self.manifest_files) do
+    if fs.has_file { manifest_file_path } then
+      table.insert(searched_manifest_files, manifest_file_path)
 
-  -- Add dependency-specific details if applicable
-  if self.required_dependencies and self.manifest_files then
-    local detected_dependencies = {}
-    local searched_manifest_files = {}
-
-    for _, manifest_file_path in ipairs(self.manifest_files) do
-      if fs.has_file { manifest_file_path } then
-        table.insert(searched_manifest_files, manifest_file_path)
-
-        for _, required_dependency_identifier in ipairs(self.required_dependencies) do
-          if fs.file_contains(manifest_file_path, required_dependency_identifier) then
-            table.insert(detected_dependencies, {
-              dependency_identifier = required_dependency_identifier,
-              found_in_manifest = manifest_file_path,
-            })
-          end
+      for _, required_dependency_identifier in ipairs(self.required_dependencies) do
+        if fs.file_contains(manifest_file_path, required_dependency_identifier) then
+          table.insert(detected_dependencies, {
+            dependency_identifier = required_dependency_identifier,
+            found_in_manifest = manifest_file_path,
+          })
         end
       end
     end
-
-    base_details.detected_dependencies = detected_dependencies
-    base_details.searched_manifest_files = searched_manifest_files
-    base_details.total_required_dependencies = #self.required_dependencies
-    base_details.total_detected_dependencies = #detected_dependencies
   end
 
-  return base_details
+  return {
+    detector_name = self.detection_name,
+    detected_at = os.time(),
+    is_detected = true,
+    detected_dependencies = detected_dependencies,
+    searched_manifest_files = searched_manifest_files,
+    total_required_dependencies = #self.required_dependencies,
+    total_detected_dependencies = #detected_dependencies,
+  }
 end
 
----Adds additional required dependencies to the detection criteria
 function Detector:add_required_dependencies(additional_dependencies)
-  if not self.required_dependencies then
-    self.required_dependencies = {}
-  end
   for _, additional_dependency_identifier in ipairs(additional_dependencies) do
     table.insert(self.required_dependencies, additional_dependency_identifier)
   end
 end
 
----Adds additional manifest files to search in
 function Detector:add_manifest_files(additional_manifest_files)
-  if not self.manifest_files then
-    self.manifest_files = {}
-  end
   for _, additional_manifest_file_path in ipairs(additional_manifest_files) do
     table.insert(self.manifest_files, additional_manifest_file_path)
   end
 end
 
----Gets the list of required dependencies
 function Detector:get_required_dependencies()
-  return vim.deepcopy(self.required_dependencies or {})
+  return vim.deepcopy(self.required_dependencies)
 end
 
----Gets the list of manifest files to search
 function Detector:get_manifest_files()
-  return vim.deepcopy(self.manifest_files or {})
+  return vim.deepcopy(self.manifest_files)
 end
 
 function Detector:_should_check_submodules()
-  if not self.manifest_files then
-    return false
-  end
-
-  -- Check if this is a Maven project
   for _, manifest_file in ipairs(self.manifest_files) do
     if manifest_file == "pom.xml" then
       return fs.has_file { "pom.xml" }
     end
   end
-
   return false
 end