mbeditor 0.5.3 → 0.7.1

data/app/services/mbeditor/ruby_definition_service.rb

@@ -18,7 +18,7 @@ module Mbeditor
   #
   # Usage:
   #   results = RubyDefinitionService.call(workspace_root, "my_method",
-  #                                        excluded_dirnames: %w[tmp .git])
+  #                                        excluded_paths: %w[tmp .git])
   #
   # Additional class methods for IntelliSense features:
   #   RubyDefinitionService.defs_in_file(abs_path)
@@ -48,54 +48,12 @@ module Mbeditor
     @cache_loaded = false
 
     class << self
-      attr_reader :file_cache, :mutex
       attr_accessor :cache_path
 
-      def call(workspace_root, symbol, excluded_dirnames: [], excluded_paths: [], included_dirs: [])
+      def call(workspace_root, symbol, excluded_paths: [], included_dirs: [])
         new(workspace_root, symbol,
-            excluded_dirnames: excluded_dirnames,
-            excluded_paths:    excluded_paths,
-            included_dirs:     included_dirs).call
-      end
-
-      # Load the JSON cache from disk exactly once per process (double-checked
-      # under the mutex so concurrent first-calls don't double-load).
-      def load_disk_cache_once
-        return if @cache_loaded
-
-        @mutex.synchronize do
-          return if @cache_loaded
-
-          @cache_loaded = true
-          path = @cache_path.to_s
-          return if path.empty? || !File.exist?(path)
-
-          raw = JSON.parse(File.read(path))
-          raw.each do |abs_path, entry|
-            @file_cache[abs_path] = {
-              mtime:         entry["mtime"].to_f,
-              lines:         entry["lines"],
-              all_defs:      entry["all_defs"],
-              module_names:  entry["module_names"],   # nil for old-format entries → triggers re-parse
-              include_calls: entry["include_calls"]   # nil for old-format entries → triggers re-parse
-            }
-          end
-        rescue StandardError
-          nil # corrupted or incompatible cache file — start fresh
-        end
-      end
-
-      # Atomically write the in-memory cache to disk (tmp-file + rename).
-      def persist_cache
-        path = @cache_path.to_s
-        return if path.empty?
-
-        snapshot = @mutex.synchronize { @file_cache.dup }
-        tmp_path = "#{path}.tmp"
-        File.write(tmp_path, JSON.generate(snapshot))
-        File.rename(tmp_path, path)
-      rescue StandardError
-        nil
+            excluded_paths: excluded_paths,
+            included_dirs:  included_dirs).call
       end
 
       # Exposed for tests.
@@ -108,11 +66,13 @@ module Mbeditor
       end
 
       # Returns all method defs in a single file from the cache (no workspace walk).
-      # The file must already be cached; returns {} if not found.
+      # Self-warms the cache for the file if not already present.
       # Result: { "method_name" => [{ line: Integer, signature: String }, ...] }
       def defs_in_file(file_path)
         load_disk_cache_once
-        entry = @mutex.synchronize { @file_cache[file_path.to_s] }
+        file_path = file_path.to_s
+        entry = @mutex.synchronize { @file_cache[file_path] }
+        entry ||= new(File.dirname(file_path), nil).send(:cache_entry_for, file_path)
         return {} unless entry
 
         entry[:all_defs].transform_values do |lines_arr|
@@ -123,7 +83,7 @@ module Mbeditor
       # Searches the cache (and triggers a workspace scan if needed) to find
       # which file in +workspace_root+ defines the given module or class name.
       # Returns the absolute file path string or nil.
-      def module_defined_in(workspace_root, module_name, excluded_dirnames: [], excluded_paths: [], included_dirs: [])
+      def module_defined_in(workspace_root, module_name, excluded_paths: [], included_dirs: [])
         load_disk_cache_once
         root_prefix = workspace_root.to_s.chomp("/")
         within_dirs = ->(path) {
@@ -137,9 +97,8 @@ module Mbeditor
 
         # Cache miss: scan workspace to populate cache entries with module_names.
         new(workspace_root, nil,
-            excluded_dirnames: excluded_dirnames,
-            excluded_paths:    excluded_paths,
-            included_dirs:     included_dirs).scan_workspace
+            excluded_paths: excluded_paths,
+            included_dirs:  included_dirs).scan_workspace
 
         result = @mutex.synchronize do
           @file_cache.find { |path, entry| within_dirs.call(path) && entry[:module_names]&.include?(module_name) }
@@ -148,39 +107,78 @@ module Mbeditor
       end
 
       # Returns the list of module/class names passed to include/extend/prepend
-      # in the given file, from the cache.  The file must already be cached;
-      # returns [] if not found.
+      # in the given file. Self-warms the cache for the file if not already present.
       def includes_in_file(file_path)
         load_disk_cache_once
-        entry = @mutex.synchronize { @file_cache[file_path.to_s] }
+        file_path = file_path.to_s
+        entry = @mutex.synchronize { @file_cache[file_path] }
+        entry ||= new(File.dirname(file_path), nil).send(:cache_entry_for, file_path)
         return [] unless entry
 
         entry[:include_calls] || []
       end
 
-      # Convenience wrapper: scan the whole workspace to warm the cache.
-      # Fast on subsequent calls (only re-parses files whose mtime changed).
-      def scan(workspace_root, excluded_dirnames: [], excluded_paths: [], included_dirs: [])
-        new(workspace_root, nil,
-            excluded_dirnames: excluded_dirnames,
-            excluded_paths:    excluded_paths,
-            included_dirs:     included_dirs).scan_workspace
+      private
+
+      attr_reader :file_cache, :mutex
+
+      # Load the JSON cache from disk exactly once per process (double-checked
+      # under the mutex so concurrent first-calls don't double-load).
+      def load_disk_cache_once
+        return if @cache_loaded
+
+        @mutex.synchronize do
+          return if @cache_loaded
+
+          @cache_loaded = true
+          path = @cache_path.to_s
+          return if path.empty? || !File.exist?(path)
+
+          raw = JSON.parse(File.read(path))
+          raw.each do |abs_path, entry|
+            @file_cache[abs_path] = {
+              mtime:         entry["mtime"].to_f,
+              lines:         entry["lines"],
+              all_defs:      entry["all_defs"],
+              module_names:  entry["module_names"],   # nil for old-format entries → triggers re-parse
+              include_calls: entry["include_calls"]   # nil for old-format entries → triggers re-parse
+            }
+          end
+        rescue StandardError
+          nil # corrupted or incompatible cache file — start fresh
+        end
+      end
+
+      # Atomically write the in-memory cache to disk (tmp-file + rename).
+      def persist_cache
+        path = @cache_path.to_s
+        return if path.empty?
+
+        snapshot = @mutex.synchronize { @file_cache.dup }
+        tmp_path = "#{path}.tmp"
+        File.write(tmp_path, JSON.generate(snapshot))
+        File.rename(tmp_path, path)
+      rescue StandardError
+        nil
       end
+
     end
 
-    def initialize(workspace_root, symbol, excluded_dirnames: [], excluded_paths: [], included_dirs: [])
+    def initialize(workspace_root, symbol, excluded_paths: [], included_dirs: [])
       @workspace_root    = workspace_root.to_s.chomp("/")
       @symbol            = symbol
-      @excluded_dirnames = Array(excluded_dirnames)
       @excluded_paths    = Array(excluded_paths)
       @included_dirs     = Array(included_dirs)
+      @exclusion_matcher = ExclusionMatcher.new(@excluded_paths)
+      @shared_cache      = self.class.send(:file_cache)
+      @shared_mutex      = self.class.send(:mutex)
     end
 
     # Walks the entire workspace and populates the per-file cache (including the
     # new module_names and include_calls fields) without filtering by symbol.
     # Used by +module_defined_in+ to ensure the cache is warm.
     def scan_workspace
-      self.class.load_disk_cache_once
+      load_disk_cache_once
       @new_entries  = false
       files_scanned = 0
       evict_deleted_cache_entries
@@ -188,15 +186,13 @@ module Mbeditor
       search_roots.each do |root|
         Find.find(root) do |path|
           if File.directory?(path)
-            dirname = File.basename(path)
-            rel_dir = relative_path(path)
-            Find.prune if path != root && excluded_dir?(dirname, rel_dir)
+            Find.prune if path != root && @exclusion_matcher.excluded?(relative_path(path))
             next
           end
           next unless path.end_with?(".rb")
 
           rel = relative_path(path)
-          next if excluded_rel_path?(rel, File.basename(path))
+          next if @exclusion_matcher.excluded?(rel)
 
           files_scanned += 1
           if files_scanned > MAX_FILES_SCANNED
@@ -211,11 +207,11 @@ module Mbeditor
         end
       end
 
-      self.class.persist_cache if @new_entries
+      persist_cache if @new_entries
     end
 
     def call
-      self.class.load_disk_cache_once
+      load_disk_cache_once
 
       results       = []
       @new_entries  = false
@@ -225,18 +221,15 @@ module Mbeditor
 
       search_roots.each do |root|
         Find.find(root) do |path|
-          # Prune excluded directories
           if File.directory?(path)
-            dirname = File.basename(path)
-            rel_dir = relative_path(path)
-            Find.prune if path != root && excluded_dir?(dirname, rel_dir)
+            Find.prune if path != root && @exclusion_matcher.excluded?(relative_path(path))
             next
           end
 
           next unless path.end_with?(".rb")
 
           rel = relative_path(path)
-          next if excluded_rel_path?(rel, File.basename(path))
+          next if @exclusion_matcher.excluded?(rel)
 
           files_scanned += 1
           if files_scanned > MAX_FILES_SCANNED
@@ -266,7 +259,7 @@ module Mbeditor
         end
       end
 
-      self.class.persist_cache if @new_entries
+      persist_cache if @new_entries
       results
     end
 
@@ -274,12 +267,12 @@ module Mbeditor
 
     # Remove cache entries for files that no longer exist on disk.
     def evict_deleted_cache_entries
-      stale_keys = self.class.mutex.synchronize do
-        self.class.file_cache.keys.select { |p| !File.exist?(p) }
+      stale_keys = @shared_mutex.synchronize do
+        @shared_cache.keys.select { |p| !File.exist?(p) }
       end
       return if stale_keys.empty?
 
-      self.class.mutex.synchronize { stale_keys.each { |k| self.class.file_cache.delete(k) } }
+      @shared_mutex.synchronize { stale_keys.each { |k| @shared_cache.delete(k) } }
       @new_entries = true
     end
 
@@ -287,7 +280,7 @@ module Mbeditor
     # been modified since the last parse.  Returns nil on any read/parse error.
     def cache_entry_for(path)
       mtime = File.mtime(path).to_f
-      cached = self.class.mutex.synchronize { self.class.file_cache[path] }
+      cached = @shared_mutex.synchronize { @shared_cache[path] }
       return cached if cached && cached[:mtime] == mtime && !cached[:module_names].nil?
 
       source                              = File.read(path, encoding: "UTF-8", invalid: :replace, undef: :replace)
@@ -296,7 +289,7 @@ module Mbeditor
       all_defs, module_names, include_calls = sexp ? collect_all_defs(sexp) : [{}, [], []]
       entry = { mtime: mtime, lines: lines, all_defs: all_defs,
                 module_names: module_names, include_calls: include_calls }
-      self.class.mutex.synchronize { self.class.file_cache[path] = entry }
+      @shared_mutex.synchronize { @shared_cache[path] = entry }
       @new_entries = true
       entry
     rescue StandardError
@@ -406,25 +399,8 @@ module Mbeditor
       dirs.empty? ? [@workspace_root] : dirs
     end
 
-    def excluded_dir?(dirname, rel_dir)
-      @excluded_dirnames.include?(dirname) ||
-        @excluded_paths.any? do |pattern|
-          if pattern.include?("/")
-            rel_dir == pattern || rel_dir.start_with?("#{pattern}/")
-          else
-            dirname == pattern
-          end
-        end
-    end
+    def load_disk_cache_once = self.class.send(:load_disk_cache_once)
+    def persist_cache        = self.class.send(:persist_cache)
 
-    def excluded_rel_path?(rel, name)
-      @excluded_paths.any? do |pattern|
-        if pattern.include?("/")
-          rel == pattern || rel.start_with?("#{pattern}/")
-        else
-          name == pattern || rel.split("/").include?(pattern)
-        end
-      end
-    end
   end
 end

data/app/services/mbeditor/schema_service.rb

@@ -0,0 +1,270 @@
+# frozen_string_literal: true
+
+module Mbeditor
+  # Parses db/schema.rb or db/structure.sql to extract table definitions.
+  # Returns nil when the schema file is missing or the table is not found.
+  #
+  # Return format:
+  #   {
+  #     table:   "users",
+  #     model:   "User",
+  #     columns: [{ name: "id", type: "integer" }, ...],
+  #     indexes: [{ name: "idx_users_on_email", columns: ["email"], unique: true }]
+  #   }
+  class SchemaService
+    SCHEMA_RB_PATH = "db/schema.rb"
+    STRUCTURE_SQL_PATH = "db/structure.sql"
+
+    def initialize(model_name, workspace_root)
+      @model_name     = model_name.to_s.strip
+      @workspace_root = workspace_root.to_s
+    end
+
+    def call
+      return nil if @model_name.empty? || @workspace_root.empty?
+
+      table_name = derive_table_name(@model_name)
+
+      # Try schema.rb first (Ruby format)
+      result = try_schema_rb(table_name)
+      return result if result
+
+      # Try structure.sql (SQL format)
+      result = try_structure_sql(table_name)
+      return result if result
+
+      Rails.logger.debug("SchemaService: table '#{table_name}' (from model '#{@model_name}') not found in db/schema.rb or db/structure.sql. Check if model has custom table_name.")
+      nil
+    end
+
+    private
+
+    # "User" → "users", "OrderItem" → "order_items", "Order Item" → "order_items"
+    def derive_table_name(model_name)
+      normalized = model_name.delete(" ")
+      ActiveSupport::Inflector.tableize(normalized)
+    end
+
+    # Try to read and parse db/schema.rb
+    def try_schema_rb(table_name)
+      schema_path = File.join(@workspace_root, SCHEMA_RB_PATH)
+      return nil unless File.exist?(schema_path)
+
+      begin
+        content = File.read(schema_path, encoding: "utf-8")
+        parse_schema_rb(content, table_name)
+      rescue Errno::ENOENT, Errno::EACCES => e
+        Rails.logger.debug("SchemaService: failed to read #{schema_path}: #{e.message}")
+        nil
+      end
+    end
+
+    # Try to read and parse db/structure.sql
+    def try_structure_sql(table_name)
+      schema_path = File.join(@workspace_root, STRUCTURE_SQL_PATH)
+      return nil unless File.exist?(schema_path)
+
+      begin
+        content = File.read(schema_path, encoding: "utf-8")
+        parse_structure_sql(content, table_name)
+      rescue Errno::ENOENT, Errno::EACCES => e
+        Rails.logger.debug("SchemaService: failed to read #{schema_path}: #{e.message}")
+        nil
+      end
+    end
+
+    # ── Schema.rb parsing (Ruby DSL) ──────────────────────────────────────
+
+    # Finds the create_table block and parses it.
+    # Uses the leading-whitespace backreference to match the correct closing `end`.
+    def parse_schema_rb(content, table_name)
+      re = /^( *)create_table\s+"#{Regexp.escape(table_name)}"([^\n]*)\n(.*?)^\1end\b/m
+      m  = content.match(re)
+      return nil unless m
+
+      body = m[3]
+
+      {
+        table:   table_name,
+        model:   @model_name,
+        columns: parse_schema_rb_columns(body),
+        indexes: parse_schema_rb_indexes(body)
+      }
+    end
+
+    # Parses `t.type "name", options...` column lines from schema.rb
+    def parse_schema_rb_columns(body)
+      columns = []
+      body.scan(/^\s+t\.(\w+)\s+"([^"]+)"(.*)$/) do |type, name, rest|
+        next if type == "index"
+
+        col = { name: name, type: type }
+        col[:null]        = false if rest.include?("null: false")
+        col[:primary_key] = true  if rest.include?("primary_key: true")
+
+        if (m = rest.match(/default:\s*(.+?)(?:,\s*\w|$)/))
+          col[:default] = m[1].strip
+        end
+        if (m = rest.match(/limit:\s*(\d+)/))
+          col[:limit] = m[1].to_i
+        end
+        if (m = rest.match(/precision:\s*(\d+)/))
+          col[:precision] = m[1].to_i
+        end
+        if (m = rest.match(/scale:\s*(\d+)/))
+          col[:scale] = m[1].to_i
+        end
+
+        columns << col
+      end
+      columns
+    end
+
+    # Parses `t.index ["col"], name: "idx", unique: true` index lines from schema.rb
+    def parse_schema_rb_indexes(body)
+      indexes = []
+      body.scan(/^\s+t\.index\s+\[([^\]]*)\](.*)$/) do |cols_str, rest|
+        cols = cols_str.scan(/"([^"]+)"/).flatten
+        next if cols.empty?
+
+        idx = { columns: cols }
+        if (m = rest.match(/name:\s*"([^"]+)"/))
+          idx[:name] = m[1]
+        end
+        idx[:unique] = true if rest.include?("unique: true")
+        indexes << idx
+      end
+      indexes
+    end
+
+    # ── Structure.sql parsing (SQL DDL) ──────────────────────────────────
+
+    # Parses structure.sql (SQL format) to extract table definition
+    def parse_structure_sql(content, table_name)
+      # Match CREATE TABLE ... ( ... ) with support for various SQL dialects
+      # Handles: PostgreSQL, MySQL, SQLite with quoted/unquoted names
+      # Ends with different delimiters: ); ENGINE...; or just );
+      quoted_name = Regexp.escape(table_name)
+      patterns = [
+        # PostgreSQL with public schema: CREATE TABLE public."users" ( ... );
+        /CREATE\s+TABLE\s+(?:IF\s+NOT\s+EXISTS\s+)?(?:public\.)?["`]?#{quoted_name}["`]?\s*\(([\s\S]*?)\)\s*;/mi,
+        # MySQL with ENGINE: CREATE TABLE `users` ( ... ) ENGINE=...;
+        /CREATE\s+TABLE\s+(?:IF\s+NOT\s+EXISTS\s+)?["`]?#{quoted_name}["`]?\s*\(([\s\S]*?)\)\s*(?:ENGINE|DEFAULT)/mi
+      ]
+
+      table_def = nil
+      patterns.each do |pattern|
+        if (m = content.match(pattern))
+          table_def = m[1]
+          break
+        end
+      end
+
+      return nil unless table_def
+
+      {
+        table:   table_name,
+        model:   @model_name,
+        columns: parse_sql_columns(table_def),
+        indexes: parse_sql_indexes(content, table_name)
+      }
+    end
+
+    # Parses column definitions from SQL CREATE TABLE body
+    def parse_sql_columns(table_def)
+      columns = []
+
+      # Process line by line to handle complex type declarations like decimal(10,2)
+      table_def.each_line do |line|
+        line = line.strip
+        next if line.empty?
+        next if line.match?(/^(PRIMARY|UNIQUE|FOREIGN|KEY|INDEX|CONSTRAINT)/i)
+
+        # Extract column name and full definition
+        # Matches: `name` type(...) constraints, name type NOT NULL, etc.
+        if (m = line.match(/^["`]?(\w+)["`]?\s+(.+?)\s*,?\s*$/i))
+          col_name = m[1]
+          definition = m[2]
+
+          # Split at constraint keywords to isolate the type
+          # Extract everything before NOT NULL, NULL, AUTO_INCREMENT, DEFAULT, PRIMARY, etc.
+          col_type_and_params = definition.split(/\s+(?:NOT\s+NULL|NULL|AUTO_INCREMENT|DEFAULT|PRIMARY|UNIQUE|CHECK|COLLATE|COMMENT|ON|USING)/i).first.strip.downcase
+
+          # Extract base type (before parentheses)
+          col_type = col_type_and_params.split('(').first.strip
+          col = { name: col_name, type: sql_type_to_rails(col_type) }
+
+          col[:null] = false if definition.match?(/\bNOT\s+NULL\b/i)
+          col[:primary_key] = true if definition.match?(/\bPRIMARY\s+KEY\b/i)
+
+          # Extract precision and scale for decimals/numeric types
+          if (pm = col_type_and_params.match(/\((\d+),\s*(\d+)\)/))
+            col[:precision] = pm[1].to_i
+            col[:scale] = pm[2].to_i
+          elsif (pm = col_type_and_params.match(/\((\d+)\)/))
+            col[:limit] = pm[1].to_i
+          end
+
+          columns << col
+        end
+      end
+
+      columns
+    end
+
+    # Parses index definitions from structure.sql
+    def parse_sql_indexes(content, table_name)
+      indexes = []
+
+      # Match CREATE INDEX ... ON table_name (columns)
+      pattern = /CREATE\s+(?:UNIQUE\s+)?INDEX\s+["`]?(\w+)["`]?\s+ON\s+(?:public\.)?["`]?#{Regexp.escape(table_name)}["`]?\s*\((.*?)\)/mi
+
+      content.scan(pattern) do |index_name, columns_str|
+        cols = columns_str.split(',').map { |c| c.strip.gsub(/["`]/, '').split(/\s+/).first }.compact
+        next if cols.empty?
+
+        idx = {
+          name: index_name,
+          columns: cols
+        }
+        idx[:unique] = true if content.match?(/CREATE\s+UNIQUE\s+INDEX\s+["`]?#{Regexp.escape(index_name)}/mi)
+
+        indexes << idx
+      end
+
+      indexes
+    end
+
+    # Map SQL types to Rails column types
+    def sql_type_to_rails(sql_type)
+      type_map = {
+        'integer' => 'integer',
+        'int' => 'integer',
+        'bigint' => 'bigint',
+        'smallint' => 'integer',
+        'bigserial' => 'bigint',
+        'serial' => 'integer',
+        'varchar' => 'string',
+        'character varying' => 'string',
+        'character' => 'string',
+        'text' => 'text',
+        'boolean' => 'boolean',
+        'bool' => 'boolean',
+        'decimal' => 'decimal',
+        'numeric' => 'decimal',
+        'float' => 'float',
+        'double' => 'float',
+        'timestamp' => 'datetime',
+        'datetime' => 'datetime',
+        'date' => 'date',
+        'time' => 'time',
+        'json' => 'json',
+        'jsonb' => 'jsonb',
+        'uuid' => 'uuid',
+        'bytea' => 'binary'
+      }
+
+      type_map[sql_type.downcase] || sql_type
+    end
+  end
+end