mbeditor 0.12.9 → 0.13.1

data/app/services/mbeditor/js_members_service.rb

@@ -18,6 +18,8 @@ module Mbeditor
     def initialize(symbol, workspace_root)
       @symbol         = symbol.to_s
       @workspace_root = workspace_root.to_s.chomp("/")
+      # Compiled once: this is matched against every line of search output.
+      @member_regex   = /#{Regexp.escape(@symbol)}\.(?:prototype\.)?([a-zA-Z_$][a-zA-Z0-9_$]*)\s*=/
     end
 
     def call
@@ -50,8 +52,7 @@ module Mbeditor
         snippet  = m[3].strip
         next unless abs_path.start_with?(@workspace_root)
 
-        s = Regexp.escape(@symbol)
-        member_match = snippet.match(/#{s}\.(?:prototype\.)?([a-zA-Z_$][a-zA-Z0-9_$]*)\s*=/)
+        member_match = snippet.match(@member_regex)
         next unless member_match
 
         name = member_match[1]

data/app/services/mbeditor/js_program_service.rb

@@ -83,8 +83,8 @@ module Mbeditor
         skipped = []
         total   = 0
 
-        each_candidate(root) do |rel, abs|
-          if File.size(abs) > MAX_FILE_BYTES
+        each_candidate(root) do |rel, abs, stat|
+          if stat.size > MAX_FILE_BYTES
             skipped << { path: rel, reason: "larger than #{MAX_FILE_BYTES} bytes" }
             next
           end
@@ -127,12 +127,16 @@ module Mbeditor
             abs = File.join(dir, name)
             rel = abs.delete_prefix(root).delete_prefix("/")
             next if m.excluded?(rel)
-            next if File.symlink?(abs)
 
-            if File.directory?(abs)
+            # One lstat answers symlink?, directory? and size — and lstat is
+            # exactly right here, since a symlink must not be followed.
+            stat = lstat(abs)
+            next if stat.nil? || stat.symlink?
+
+            if stat.directory?
               stack.push(abs)
             elsif name.match?(SOURCE_EXT) && !name.match?(MINIFIED_NAME)
-              yield rel, abs
+              yield rel, abs, stat
             end
           end
         end
@@ -144,6 +148,12 @@ module Mbeditor
         []
       end
 
+      def lstat(abs)
+        File.lstat(abs)
+      rescue SystemCallError
+        nil
+      end
+
       def matcher(root)
         ExclusionMatcher.new(exclusion_patterns, root: root)
       end

data/app/services/mbeditor/js_syntax_check_service.rb

@@ -218,6 +218,12 @@ module Mbeditor
       def scope_lint(workspace_root, source)
         return [] unless available? && Mbeditor.configuration.js_scope_lint != false
 
+        # Gathered before taking MUTEX: both walk the workspace under their own
+        # locks, and holding this one across them serialises every JS save
+        # behind whichever save is rebuilding the program.
+        program = JsProgramService.call(workspace_root.to_s)
+        globals = JsGlobalsService.call(workspace_root.to_s)
+
         MUTEX.synchronize do
           begin
             ctx = context
@@ -227,7 +233,7 @@ module Mbeditor
             @lint_helpers_loaded = true
             return [] unless ctx.eval("typeof __mbLint !== 'undefined'")
 
-            names = whitelist(ctx, workspace_root)
+            names = whitelist(ctx, program, globals)
             findings = ctx.eval("__mbLint.lint(#{source.to_json}, #{names.to_json}, #{MAX_SCOPE_FINDINGS})")
 
             @checks_run = (@checks_run || 0) + 1
@@ -268,6 +274,13 @@ module Mbeditor
       end
 
       def reset_context!
+        # Dropping the reference leaks the V8 isolate until the GC finalizer
+        # runs; dispose releases it now.
+        begin
+          @context&.dispose
+        rescue StandardError
+          nil
+        end
         @context = nil
         @checks_run = 0
         @lint_helpers_loaded = false
@@ -278,12 +291,11 @@ module Mbeditor
       # plus the browser and React layers. Per-file declaration names are
       # cached by content digest, so a steady-state save re-parses only the
       # files that changed since the last lint.
-      def whitelist(ctx, workspace_root)
+      def whitelist(ctx, program, globals)
         names = []
         @decl_cache ||= {}
         live = {}
 
-        program = JsProgramService.call(workspace_root.to_s)
         Array(program[:files]).each do |f|
           digest = f[:content].hash
           entry = @decl_cache[f[:path]]
@@ -293,7 +305,6 @@ module Mbeditor
         end
         @decl_cache = live
 
-        globals = JsGlobalsService.call(workspace_root.to_s)
         names.concat(Array(globals[:symbols]).map { |s| s[:name].to_s })
 
         (names + BROWSER_GLOBALS + REACT_GLOBALS).uniq

data/app/services/mbeditor/process_runner.rb

@@ -8,7 +8,13 @@ module Mbeditor
 
     class TimeoutError < StandardError; end
 
-    def call(cmd, timeout: nil, env: {}, stdin_data: nil, chdir: nil)
+    CHUNK_BYTES = 64 * 1024
+    private_constant :CHUNK_BYTES
+
+    # +max_bytes+ bounds how much of each stream is kept in memory (nil =
+    # unbounded). Anything past the cap is still read and discarded — stopping
+    # would block the child on a full pipe and hang the wait below.
+    def call(cmd, timeout: nil, env: {}, stdin_data: nil, chdir: nil, max_bytes: nil)
       out = +""
       err = +""
       exit_status = nil
@@ -21,28 +27,52 @@ module Mbeditor
         stdin.write(stdin_data) if stdin_data
         stdin.close
 
-        timer = if timeout
-          Thread.new do
-            sleep timeout
-            timed_out = true
-            Process.kill("-KILL", wait_thr.pid)
-          rescue Errno::ESRCH
-            nil
+        out_thread = Thread.new { out = read_capped(stdout, max_bytes) }
+        err_thread = Thread.new { err = read_capped(stderr, max_bytes) }
+
+        # A deadline join rather than a timer thread: a timer racing normal
+        # exit could flag a timeout (and SIGKILL a recycled pid) after the
+        # process had already succeeded. The reader threads above keep the
+        # pipes drained meanwhile, so this cannot deadlock.
+        if timeout
+          deadline  = Process.clock_gettime(Process::CLOCK_MONOTONIC) + timeout
+          timed_out = !wait_thr.join(timeout)
+
+          # A grandchild that inherited the pipe holds it open after the child
+          # exits, so the unbounded joins below could outlive the process
+          # itself. Bound them by the same deadline the timer thread enforced.
+          remaining = [deadline - Process.clock_gettime(Process::CLOCK_MONOTONIC), 0].max
+          overrun   = !out_thread.join(remaining) || !err_thread.join(remaining)
+
+          if timed_out || overrun
+            begin
+              Process.kill("-KILL", wait_thr.pid)
+            rescue Errno::ESRCH
+              nil
+            end
           end
         end
 
-        out_thread = Thread.new { out = stdout.read }
-        err_thread = Thread.new { err = stderr.read }
         out_thread.join
         err_thread.join
-
         exit_status = wait_thr.value
-        timer&.kill
       end
 
       raise TimeoutError, "process timed out after #{timeout}s" if timed_out
 
       { stdout: out, stderr: err, exit_status: exit_status }
     end
+
+    def read_capped(io, max_bytes)
+      return io.read.to_s unless max_bytes
+
+      buf = +""
+      while (chunk = io.read(CHUNK_BYTES))
+        buf << chunk if buf.bytesize < max_bytes
+      end
+      # IO#read with a length returns binary; IO#read without one applies the
+      # default external encoding, and callers expect the latter.
+      buf.force_encoding(Encoding.default_external)
+    end
   end
 end

data/app/services/mbeditor/ri_definition_service.rb

@@ -30,6 +30,10 @@ module Mbeditor
       Struct Set Time File IO Exception Proc Method NilClass
     ].freeze
 
+    # Keyed by symbol, so a long session accumulates one entry per name ever
+    # hovered. Cleared wholesale at the cap — the next lookups just re-run ri.
+    MAX_CACHE_ENTRIES = 500
+
     @cache = {}
     @mutex = Mutex.new
 
@@ -39,7 +43,10 @@ module Mbeditor
         return cached unless cached.nil?
 
         result = new(symbol).call
-        @mutex.synchronize { @cache[symbol] = result }
+        @mutex.synchronize do
+          @cache.clear if @cache.size >= MAX_CACHE_ENTRIES
+          @cache[symbol] = result
+        end
         result
       end
 

data/app/services/mbeditor/route_service.rb

@@ -12,13 +12,6 @@ module Mbeditor
   module RouteService
     module_function
 
-    # Actions with no route are worth calling out, but only for controllers Rails
-    # would actually dispatch to. These are the inherited ones every controller
-    # has and nobody routes.
-    NON_ACTION_METHODS = %w[
-      new inspect method_of to_s hash class dup freeze
-    ].freeze
-
     # "app/controllers/admin/users_controller.rb" -> "admin/users", which is the
     # key Rails stores in a route's defaults.
     def controller_key(relative_path)
@@ -29,18 +22,62 @@ module Mbeditor
       match[1]
     end
 
+    MUTEX = Mutex.new
+    private_constant :MUTEX
+
+    # Matches the other read-through caches in this engine (FileTreeService 15s,
+    # GitInfoService 10s). A write invalidates it outright, so the TTL only ever
+    # bounds staleness from a route change made outside the editor.
+    CACHE_TTL = 10
+
     # => { "show" => [{ verb:, path:, name: }], ... }
+    #
+    # Cached because every call walks the host app's ENTIRE route set, and the
+    # caller is the inline route hints — which re-request on every activation of
+    # a controller tab and on every external content change. Switching between
+    # two controllers repeatedly was therefore a full O(routes) scan per switch,
+    # and a large app has thousands of routes. The scan itself is unchanged;
+    # it just stops happening once per glance.
     def for_controller(key)
       return {} if key.nil? || key.empty?
       return {} unless defined?(Rails) && Rails.respond_to?(:application) && Rails.application
 
-      routes_for(key)
+      cached = cached_routes(key)
+      return cached if cached
+
+      # Built outside the mutex: it runs arbitrary host-app route code, and
+      # holding the lock across it would serialise every other controller's
+      # lookup behind the slowest one.
+      computed = routes_for(key)
+      store_routes(key, computed)
+      computed
     rescue StandardError
       # A broken route set must not take the editor down with it — the file still
       # opens, just without hints.
       {}
     end
 
+    def invalidate
+      MUTEX.synchronize { @cache = {} }
+      nil
+    end
+
+    def cached_routes(key)
+      MUTEX.synchronize do
+        entry = (@cache ||= {})[key]
+        return entry[:data] if entry && (Process.clock_gettime(Process::CLOCK_MONOTONIC) - entry[:ts]) < CACHE_TTL
+      end
+      nil
+    end
+    private_class_method :cached_routes
+
+    def store_routes(key, data)
+      MUTEX.synchronize do
+        (@cache ||= {})[key] = { ts: Process.clock_gettime(Process::CLOCK_MONOTONIC), data: data }
+      end
+    end
+    private_class_method :store_routes
+
     def routes_for(key)
       out = {}
       Rails.application.routes.routes.each do |route|

data/app/services/mbeditor/rubocop_run_service.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require "json"
+require "tmpdir"
+
+module Mbeditor
+  # Whole-workspace `rubocop` run — the counterpart to the per-buffer /lint
+  # endpoint, which can only report on files Monaco already has open.
+  #
+  # `-a` (safe autocorrect) rather than `-A`: unsafe corrections can change
+  # behaviour, and this runs over every file in the project at once, so an
+  # unreviewed `-A` is a much bigger blast radius than the per-buffer quick fix.
+  module RubocopRunService
+    module_function
+
+    def run(workspace_root, mode: :check, timeout: 300)
+      matcher = ExclusionMatcher.new(Mbeditor.configuration.excluded_paths, root: workspace_root)
+      cmd = AvailabilityProbe.rubocop_command(workspace_root) +
+            [AvailabilityProbe.rubocop_server_flag(workspace_root), "--format", "json", "--no-color"]
+      cmd << "-a" if mode.to_sym == :autocorrect
+
+      result = ProcessRunner.call(
+        cmd,
+        timeout: timeout,
+        chdir: workspace_root.to_s,
+        env: { "RUBOCOP_CACHE_ROOT" => File.join(Dir.tmpdir, "rubocop") }
+      )
+      parse(result[:stdout], result[:stderr], matcher, mode: mode)
+    rescue ProcessRunner::TimeoutError
+      error("RuboCop timed out after #{timeout}s")
+    rescue StandardError => e
+      error(e.message)
+    end
+
+    # RuboCop writes its JSON to stdout, but anything the host app prints while
+    # loading (a deprecation warning, a bundler notice) lands in front of it —
+    # hence the seek to the first brace, same as the /lint path.
+    # +matcher+ drops offenses in paths the workspace excludes — vendored gems
+    # above all. RuboCop's own defaults exclude `vendor/**/*`, but a host
+    # .rubocop.yml that sets AllCops/Exclude without `inherit_mode: merge`
+    # silently replaces them, and the panel then fills with gem source.
+    #
+    # ponytail: filtered after the fact, so a host in that state still pays for
+    # the walk. Generate a config that inherits from theirs and re-adds the
+    # excludes if the run time ever becomes the complaint.
+    #
+    # `-a` reports what it *fixed* alongside what it left: a corrected offense
+    # still appears in the JSON, with `corrected: true` and `correctable: true`.
+    # Rendering those made the Fix button look inert — the list after a run was
+    # byte-identical to the list before it, and the correctable tally never
+    # moved, so the button stayed lit and every further click was a slow no-op.
+    # They are dropped here rather than at the panel because /rubocop's response
+    # is documented as the post-correction offense list.
+    def parse(stdout, stderr = nil, matcher = nil, mode: :check)
+      idx = stdout.index("{")
+      return error(stderr.to_s.strip.split("\n").last || "RuboCop produced no output") unless idx
+
+      data = JSON.parse(stdout[idx..])
+      files = (data["files"] || []).filter_map do |file|
+        next if matcher&.excluded?(file["path"].to_s)
+
+        offenses = (file["offenses"] || []).reject { |o| o["corrected"] == true }
+        next if offenses.empty?
+
+        { path: file["path"], offenses: offenses.map { |o| offense(o) } }
+      end
+
+      {
+        ok: true,
+        files: files.sort_by { |f| f[:path].to_s },
+        summary: data["summary"] || {},
+        # RuboCop's `correctable` means "a cop could rewrite this", safely or
+        # not. `-a` already looped to convergence, so whatever survived it needs
+        # `-A` — which this whole-workspace path deliberately never runs. Left
+        # as the raw tally, the Fix button never disabled: Style/
+        # FrozenStringLiteralComment and friends are correctable forever.
+        correctable: mode.to_sym == :autocorrect ? 0 : files.sum { |f| f[:offenses].count { |o| o[:correctable] } }
+      }
+    rescue JSON::ParserError => e
+      error(e.message)
+    end
+
+    def offense(o)
+      {
+        copName: o["cop_name"],
+        message: o["message"],
+        severity: o["severity"],
+        correctable: o["correctable"] == true,
+        line: o.dig("location", "start_line") || o.dig("location", "line") || 1,
+        column: o.dig("location", "start_column") || o.dig("location", "column") || 1
+      }
+    end
+
+    def error(message)
+      { ok: false, error: message, files: [], summary: {}, correctable: 0 }
+    end
+  end
+end

data/app/services/mbeditor/ruby_definition_service.rb

@@ -34,6 +34,8 @@ module Mbeditor
     # Upper bound on cached files. Entries carry full file contents, so this
     # caps both the on-disk JSON and the resident hash.
     MAX_CACHE_ENTRIES = 2_000
+    # Minimum gap between disk writes of that cache (seconds).
+    PERSIST_INTERVAL = 30
 
     # In-process file-index cache.
     # Structure: { absolute_path => {
@@ -63,6 +65,7 @@ module Mbeditor
       def clear_cache!
         @mutex.synchronize { @file_cache.clear; @cache_loaded = false }
         @last_evict_at = nil
+        @last_persist_at = nil
         path = @cache_path.to_s
         File.delete(path) if !path.empty? && File.exist?(path)
       rescue StandardError
@@ -154,10 +157,18 @@ module Mbeditor
       end
 
       # Atomically write the in-memory cache to disk (tmp-file + rename).
+      # Debounced: the snapshot carries every cached file's full source, so a
+      # lookup that parsed one new file would otherwise rewrite tens of MB of
+      # JSON. Skipping a write only delays it — the entries stay in memory and
+      # a later lookup flushes them.
       def persist_cache
         path = @cache_path.to_s
         return if path.empty?
 
+        now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        return if @last_persist_at && (now - @last_persist_at) < PERSIST_INTERVAL
+
+        @last_persist_at = now
         snapshot = @mutex.synchronize do
           # Each entry holds the file's full source lines, so an uncapped cache
           # grows to tens of MB on a large workspace and is rewritten in full on
@@ -263,7 +274,10 @@ module Mbeditor
                 signature: (cached[:lines][def_line - 1] || "").strip,
                 comments:  extract_comments(cached[:lines], def_line)
               }
-              return results if results.length >= MAX_RESULTS
+              if results.length >= MAX_RESULTS
+                persist_cache if @new_entries
+                return results
+              end
             end
           rescue StandardError
             # Malformed file or unreadable; skip silently
@@ -284,14 +298,19 @@ module Mbeditor
 
     def evict_deleted_cache_entries
       now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-      stale_keys = @shared_mutex.synchronize do
+      keys = @shared_mutex.synchronize do
         last = self.class.instance_variable_get(:@last_evict_at)
         next nil if last && (now - last) < EVICT_INTERVAL
 
         self.class.instance_variable_set(:@last_evict_at, now)
-        @shared_cache.keys.select { |p| !File.exist?(p) }
+        @shared_cache.keys
       end
-      return if stale_keys.nil? || stale_keys.empty?
+      return if keys.nil?
+
+      # stat()ing outside the lock: up to MAX_CACHE_ENTRIES syscalls, and every
+      # other cache reader would otherwise wait on them.
+      stale_keys = keys.reject { |p| File.exist?(p) }
+      return if stale_keys.empty?
 
       @shared_mutex.synchronize { stale_keys.each { |k| @shared_cache.delete(k) } }
       @new_entries = true

data/app/services/mbeditor/schema_service.rb

@@ -44,10 +44,16 @@ module Mbeditor
     def derive_table_name(model_name)
       normalized = model_name.delete(" ")
 
-      # Check model file for an explicit table_name override
+      # Check model file for an explicit table_name override.
+      #
+      # Inflector.underscore is not a sanitizer — it leaves "../" untouched, so
+      # a model name reaches this join as a path fragment. Callers are expected
+      # to have validated the name, but the containment check is repeated here
+      # so the service is safe on its own; it also covers a symlink under
+      # app/models pointing outside the workspace, which no name check can.
       singular = ActiveSupport::Inflector.underscore(normalized)
       model_file = File.join(@workspace_root, "app", "models", "#{singular}.rb")
-      if File.exist?(model_file)
+      if SafePath.within?(@workspace_root, model_file) && File.exist?(model_file)
         begin
           source = File.read(model_file, encoding: "utf-8")
           # Matches: self.table_name = "name"  or  = :name  or  = 'name'
@@ -235,10 +241,11 @@ module Mbeditor
     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
+      # Match CREATE INDEX ... ON table_name (columns). UNIQUE is captured here
+      # rather than re-scanned per index with a freshly compiled regex.
+      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|
+      content.scan(pattern) do |unique, index_name, columns_str|
         cols = columns_str.split(',').map { |c| c.strip.gsub(/["`]/, '').split(/\s+/).first }.compact
         next if cols.empty?
 
@@ -246,7 +253,7 @@ module Mbeditor
           name: index_name,
           columns: cols
         }
-        idx[:unique] = true if content.match?(/CREATE\s+UNIQUE\s+INDEX\s+["`]?#{Regexp.escape(index_name)}/mi)
+        idx[:unique] = true if unique
 
         indexes << idx
       end
@@ -255,67 +262,67 @@ module Mbeditor
     end
 
     # Map SQL types to Rails column types
-    def sql_type_to_rails(sql_type)
-      type_map = {
-        'integer' => 'integer',
-        'int' => 'integer',
-        'int4' => 'integer',
-        'int2' => 'integer',
-        'int8' => 'bigint',
-        'bigint' => 'bigint',
-        'smallint' => 'integer',
-        'bigserial' => 'bigint',
-        'serial' => 'integer',
-        'varchar' => 'string',
-        'character varying' => 'string',
-        'character' => 'string',
-        'char' => 'string',
-        'text' => 'text',
-        'citext' => 'string',
-        'boolean' => 'boolean',
-        'bool' => 'boolean',
-        'decimal' => 'decimal',
-        'numeric' => 'decimal',
-        'real' => 'float',
-        'float' => 'float',
-        'float4' => 'float',
-        'float8' => 'float',
-        'double precision' => 'float',
-        'double' => 'float',
-        'money' => 'decimal',
-        'timestamp' => 'datetime',
-        'timestamp without time zone' => 'datetime',
-        'timestamp with time zone' => 'datetime',
-        'timestamptz' => 'datetime',
-        'datetime' => 'datetime',
-        'date' => 'date',
-        'time' => 'time',
-        'time without time zone' => 'time',
-        'time with time zone' => 'time',
-        'interval' => 'string',
-        'json' => 'json',
-        'jsonb' => 'jsonb',
-        'uuid' => 'uuid',
-        'bytea' => 'binary',
-        'bit' => 'string',
-        'bit varying' => 'string',
-        'inet' => 'string',
-        'cidr' => 'string',
-        'macaddr' => 'string',
-        'xml' => 'string',
-        'hstore' => 'hstore',
-        'tsvector' => 'string',
-        'ltree' => 'string',
-        'point' => 'string',
-        'line' => 'string',
-        'lseg' => 'string',
-        'box' => 'string',
-        'path' => 'string',
-        'polygon' => 'string',
-        'circle' => 'string'
-      }
+    SQL_TYPE_TO_RAILS = {
+      'integer' => 'integer',
+      'int' => 'integer',
+      'int4' => 'integer',
+      'int2' => 'integer',
+      'int8' => 'bigint',
+      'bigint' => 'bigint',
+      'smallint' => 'integer',
+      'bigserial' => 'bigint',
+      'serial' => 'integer',
+      'varchar' => 'string',
+      'character varying' => 'string',
+      'character' => 'string',
+      'char' => 'string',
+      'text' => 'text',
+      'citext' => 'string',
+      'boolean' => 'boolean',
+      'bool' => 'boolean',
+      'decimal' => 'decimal',
+      'numeric' => 'decimal',
+      'real' => 'float',
+      'float' => 'float',
+      'float4' => 'float',
+      'float8' => 'float',
+      'double precision' => 'float',
+      'double' => 'float',
+      'money' => 'decimal',
+      'timestamp' => 'datetime',
+      'timestamp without time zone' => 'datetime',
+      'timestamp with time zone' => 'datetime',
+      'timestamptz' => 'datetime',
+      'datetime' => 'datetime',
+      'date' => 'date',
+      'time' => 'time',
+      'time without time zone' => 'time',
+      'time with time zone' => 'time',
+      'interval' => 'string',
+      'json' => 'json',
+      'jsonb' => 'jsonb',
+      'uuid' => 'uuid',
+      'bytea' => 'binary',
+      'bit' => 'string',
+      'bit varying' => 'string',
+      'inet' => 'string',
+      'cidr' => 'string',
+      'macaddr' => 'string',
+      'xml' => 'string',
+      'hstore' => 'hstore',
+      'tsvector' => 'string',
+      'ltree' => 'string',
+      'point' => 'string',
+      'line' => 'string',
+      'lseg' => 'string',
+      'box' => 'string',
+      'path' => 'string',
+      'polygon' => 'string',
+      'circle' => 'string'
+    }.freeze
 
-      type_map[sql_type.downcase] || sql_type
+    def sql_type_to_rails(sql_type)
+      SQL_TYPE_TO_RAILS[sql_type.downcase] || sql_type
     end
   end
 end