Refactor: Lexical Core naming (lexical-lsp#129)

* Refactor: Lexical Core naming

The name `SourceFile` was carried over from elixir-ls, and I have
never been enamored with the name, since it's long and kind of a
lie. They're not really files. Seems to me, they're Documents, which
is what the language server spec calls them.

To that end, here are the name changes I made:

Lexical.DocumentContainer => Lexical.Document.Container
Lexical.SourceFile => Lexical.Document
Lexical.SourceFile.Document => Lexical.Document.Lines
Lexical.SourceFile.DocumentEdits => Lexical.Document.Changes
Lexical.SourceFile.Edit => Lexical.Document.Edit
Lexical.SourceFile.Position => Lexical.Document.Position
Lexical.SourceFile.Range => Lexical.Document.Range

I feel that this naming is a lot nicer than before

Author: scohen

apps/common/lib/lexical/convertible.ex

@@ -1,7 +1,9 @@
 defmodule Lexical.Convertible.Helpers do
+  alias Lexical.Document
+
   def apply(%{} = map, func, context_document) do
     Enum.reduce_while(map, [], fn {key, value}, acc ->
-      context_document = Lexical.DocumentContainer.context_document(value, context_document)
+      context_document = Document.Container.context_document(value, context_document)
 
       case func.(value, context_document) do
         {:ok, native} ->
@@ -16,7 +18,7 @@ defmodule Lexical.Convertible.Helpers do
   def apply(enumerable, func, context_document) do
     result =
       Enum.reduce_while(enumerable, [], fn elem, acc ->
-        context_document = Lexical.DocumentContainer.context_document(elem, context_document)
+        context_document = Document.Container.context_document(elem, context_document)
 
         case func.(elem, context_document) do
           {:ok, native} ->
@@ -38,7 +40,7 @@ defmodule Lexical.Convertible.Helpers do
 end
 
 defprotocol Lexical.Convertible do
-  alias Lexical.DocumentContainer
+  alias Lexical.Document
 
   @fallback_to_any true
 
@@ -52,13 +54,13 @@ defprotocol Lexical.Convertible do
   @doc """
   Converts the structure to a native implementation
   """
-  @spec to_native(t, DocumentContainer.maybe_context_document()) :: native_response()
+  @spec to_native(t, Document.Container.maybe_context_document()) :: native_response()
   def to_native(t, context_document)
 
   @doc """
   Converts the native representation to a LSP compatible struct
   """
-  @spec to_lsp(t, DocumentContainer.maybe_context_document()) :: lsp_response()
+  @spec to_lsp(t, Document.Container.maybe_context_document()) :: lsp_response()
   def to_lsp(t, context_document)
 end
 
@@ -108,11 +110,11 @@ end
 
 defimpl Lexical.Convertible, for: Any do
   alias Lexical.Convertible
-  alias Lexical.DocumentContainer
+  alias Lexical.Document
   alias Lexical.Convertible.Helpers
 
   def to_native(%_struct_module{} = struct, context_document) do
-    context_document = DocumentContainer.context_document(struct, context_document)
+    context_document = Document.Container.context_document(struct, context_document)
 
     result =
       struct
@@ -133,7 +135,7 @@ defimpl Lexical.Convertible, for: Any do
   end
 
   def to_lsp(%_struct_module{} = struct, context_document) do
-    context_document = DocumentContainer.context_document(struct, context_document)
+    context_document = Document.Container.context_document(struct, context_document)
 
     result =
       struct

apps/common/lib/lexical/source_file.ex apps/common/lib/lexical/document.ex

@@ -1,32 +1,32 @@
-defmodule Lexical.SourceFile do
+defmodule Lexical.Document do
   @moduledoc """
   A representation of a LSP text document
 
-  A source file is the fundamental data structure of the Lexical language server.
+  A document is the fundamental data structure of the Lexical language server.
   All language server documents are represented and backed by source files, which
   provide functionality for fetching lines, applying changes, and tracking versions.
   """
   alias Lexical.Convertible
-  alias Lexical.SourceFile.Document
-  alias Lexical.SourceFile.Edit
-  alias Lexical.SourceFile.Line
-  alias Lexical.SourceFile.Position
-  alias Lexical.SourceFile.Range
+  alias Lexical.Document.Edit
+  alias Lexical.Document.Line
+  alias Lexical.Document.Lines
+  alias Lexical.Document.Position
+  alias Lexical.Document.Range
 
-  import Lexical.SourceFile.Line
+  import Lexical.Document.Line
 
-  alias __MODULE__.Path, as: SourceFilePath
+  alias __MODULE__.Path, as: DocumentPath
 
-  @derive {Inspect, only: [:path, :version, :dirty?, :document]}
+  @derive {Inspect, only: [:path, :version, :dirty?, :lines]}
 
-  defstruct [:uri, :path, :version, dirty?: false, document: nil]
+  defstruct [:uri, :path, :version, dirty?: false, lines: nil]
 
   @type version :: non_neg_integer()
   @type t :: %__MODULE__{
           uri: String.t(),
           version: version(),
           dirty?: boolean,
-          document: Document.t(),
+          lines: Lines.t(),
           path: String.t()
         }
 
@@ -35,44 +35,44 @@ defmodule Lexical.SourceFile do
   # public
 
   @doc """
-  Creates a new source fie from a uri or path, the source code
+  Creates a new document from a uri or path, the source code
   as a binary and the vewrsion.
   """
   @spec new(Lexical.path() | Lexical.uri(), String.t(), version()) :: t
   def new(maybe_uri, text, version) do
-    uri = SourceFilePath.ensure_uri(maybe_uri)
+    uri = DocumentPath.ensure_uri(maybe_uri)
 
     %__MODULE__{
       uri: uri,
       version: version,
-      document: Document.new(text),
-      path: SourceFilePath.from_uri(uri)
+      lines: Lines.new(text),
+      path: DocumentPath.from_uri(uri)
     }
   end
 
   @doc """
   Returns the number of lines in the document
   """
   @spec size(t) :: non_neg_integer()
-  def size(%__MODULE__{} = source) do
-    Document.size(source.document)
+  def size(%__MODULE__{} = document) do
+    Lines.size(document.lines)
   end
 
   @doc """
-  Marks the source file as dirty
+  Marks the document file as dirty
   """
   @spec mark_dirty(t) :: t
-  def mark_dirty(%__MODULE__{} = source) do
-    %__MODULE__{source | dirty?: true}
+  def mark_dirty(%__MODULE__{} = document) do
+    %__MODULE__{document | dirty?: true}
   end
 
   @doc """
-  Marks the source file as clean
+  Marks the document file as clean
   """
 
   @spec mark_clean(t) :: t
-  def mark_clean(%__MODULE__{} = source) do
-    %__MODULE__{source | dirty?: false}
+  def mark_clean(%__MODULE__{} = document) do
+    %__MODULE__{document | dirty?: false}
   end
 
   @doc """
@@ -81,16 +81,16 @@ defmodule Lexical.SourceFile do
   Returns {:ok, text} if the line exists, and :error if it doesn't
   """
   @spec fetch_text_at(t, version()) :: {:ok, String.t()} | :error
-  def fetch_text_at(%__MODULE__{} = source, line_number) do
-    case fetch_line_at(source, line_number) do
+  def fetch_text_at(%__MODULE__{} = document, line_number) do
+    case fetch_line_at(document, line_number) do
       {:ok, line(text: text)} -> {:ok, text}
       _ -> :error
     end
   end
 
   @spec fetch_line_at(t, version()) :: {:ok, Line.t()} | :error
-  def fetch_line_at(%__MODULE__{} = source, line_number) do
-    case Document.fetch_line(source.document, line_number) do
+  def fetch_line_at(%__MODULE__{} = document, line_number) do
+    case Lines.fetch_line(document.lines, line_number) do
       {:ok, line} -> {:ok, line}
       _ -> :error
     end
@@ -103,97 +103,97 @@ defmodule Lexical.SourceFile do
     {:error, :invalid_version}
   end
 
-  def apply_content_changes(%__MODULE__{} = source, _, []) do
-    {:ok, source}
+  def apply_content_changes(%__MODULE__{} = document, _, []) do
+    {:ok, document}
   end
 
-  def apply_content_changes(%__MODULE__{} = source, version, changes) when is_list(changes) do
+  def apply_content_changes(%__MODULE__{} = document, version, changes) when is_list(changes) do
     result =
-      Enum.reduce_while(changes, source, fn
-        nil, source ->
-          {:cont, source}
+      Enum.reduce_while(changes, document, fn
+        nil, document ->
+          {:cont, document}
 
-        change, source ->
-          case apply_change(source, change) do
-            {:ok, new_source} ->
-              {:cont, new_source}
+        change, document ->
+          case apply_change(document, change) do
+            {:ok, new_document} ->
+              {:cont, new_document}
 
             error ->
               {:halt, error}
           end
       end)
 
     case result do
-      %__MODULE__{} = source ->
-        source = mark_dirty(%__MODULE__{source | version: version})
+      %__MODULE__{} = document ->
+        document = mark_dirty(%__MODULE__{document | version: version})
 
-        {:ok, source}
+        {:ok, document}
 
       error ->
         error
     end
   end
 
-  def to_string(%__MODULE__{} = source) do
-    source
+  def to_string(%__MODULE__{} = document) do
+    document
     |> to_iodata()
     |> IO.iodata_to_binary()
   end
 
   # private
 
-  defp line_count(%__MODULE__{} = source) do
-    Document.size(source.document)
+  defp line_count(%__MODULE__{} = document) do
+    Lines.size(document.lines)
   end
 
   defp apply_change(
-         %__MODULE__{} = source,
+         %__MODULE__{} = document,
          %Range{start: %Position{} = start_pos, end: %Position{} = end_pos},
          new_text
        ) do
     start_line = start_pos.line
 
     new_lines_iodata =
       cond do
-        start_line > line_count(source) ->
-          append_to_end(source, new_text)
+        start_line > line_count(document) ->
+          append_to_end(document, new_text)
 
         start_line < 1 ->
-          prepend_to_beginning(source, new_text)
+          prepend_to_beginning(document, new_text)
 
         true ->
-          apply_valid_edits(source, new_text, start_pos, end_pos)
+          apply_valid_edits(document, new_text, start_pos, end_pos)
       end
 
     new_document =
       new_lines_iodata
       |> IO.iodata_to_binary()
-      |> Document.new()
+      |> Lines.new()
 
-    {:ok, %__MODULE__{source | document: new_document}}
+    {:ok, %__MODULE__{document | lines: new_document}}
   end
 
-  defp apply_change(%__MODULE__{} = source, %Edit{range: nil} = edit) do
-    {:ok, %__MODULE__{source | document: Document.new(edit.text)}}
+  defp apply_change(%__MODULE__{} = document, %Edit{range: nil} = edit) do
+    {:ok, %__MODULE__{document | lines: Lines.new(edit.text)}}
   end
 
-  defp apply_change(%__MODULE__{} = source, %Edit{range: %Range{}} = edit) do
+  defp apply_change(%__MODULE__{} = document, %Edit{range: %Range{}} = edit) do
     if valid_edit?(edit) do
-      apply_change(source, edit.range, edit.text)
+      apply_change(document, edit.range, edit.text)
     else
       {:error, {:invalid_range, edit.range}}
     end
   end
 
-  defp apply_change(%__MODULE__{} = source, %{range: range, text: text}) do
-    with {:ok, native_range} <- Convertible.to_native(range, source) do
-      apply_change(source, Edit.new(text, native_range))
+  defp apply_change(%__MODULE__{} = document, %{range: range, text: text}) do
+    with {:ok, native_range} <- Convertible.to_native(range, document) do
+      apply_change(document, Edit.new(text, native_range))
     end
   end
 
-  defp apply_change(%__MODULE__{} = source, convertable_edit) do
-    with {:ok, edit} <- Convertible.to_native(convertable_edit, source) do
-      apply_change(source, edit)
+  defp apply_change(%__MODULE__{} = document, convertable_edit) do
+    with {:ok, edit} <- Convertible.to_native(convertable_edit, document) do
+      apply_change(document, edit)
     end
   end
 
@@ -204,16 +204,16 @@ defmodule Lexical.SourceFile do
       end_pos.character >= 0
   end
 
-  defp append_to_end(%__MODULE__{} = source, edit_text) do
-    [to_iodata(source), edit_text]
+  defp append_to_end(%__MODULE__{} = document, edit_text) do
+    [to_iodata(document), edit_text]
   end
 
-  defp prepend_to_beginning(%__MODULE__{} = source, edit_text) do
-    [edit_text, to_iodata(source)]
+  defp prepend_to_beginning(%__MODULE__{} = document, edit_text) do
+    [edit_text, to_iodata(document)]
   end
 
-  defp apply_valid_edits(%__MODULE__{} = source, edit_text, start_pos, end_pos) do
-    Document.reduce(source.document, [], fn line() = line, acc ->
+  defp apply_valid_edits(%__MODULE__{} = document, edit_text, start_pos, end_pos) do
+    Lines.reduce(document.lines, [], fn line() = line, acc ->
       case edit_action(line, edit_text, start_pos, end_pos) do
         :drop ->
           acc
@@ -268,11 +268,7 @@ defmodule Lexical.SourceFile do
     binary_part(text, start_index, length)
   end
 
-  defp to_iodata(%__MODULE__{} = source) do
-    Document.to_iodata(source.document)
+  defp to_iodata(%__MODULE__{} = document) do
+    Lines.to_iodata(document.lines)
   end
-
-  # defp increment_version(%__MODULE__{} = source) do
-  #   %__MODULE__{source | version: source.version + 1}
-  # end
 end

apps/common/lib/lexical/document_container.ex apps/common/lib/lexical/document/container.ex

@@ -1,26 +1,26 @@
-defprotocol Lexical.DocumentContainer do
-  alias Lexical.SourceFile
+defprotocol Lexical.Document.Container do
+  alias Lexical.Document
   @fallback_to_any true
-  @type maybe_context_document :: SourceFile.t() | nil
+  @type maybe_context_document :: Document.t() | nil
 
   @spec context_document(t, maybe_context_document()) :: maybe_context_document()
   def context_document(t, parent_context_document)
 end
 
-defimpl Lexical.DocumentContainer, for: Any do
-  alias Lexical.SourceFile
+defimpl Lexical.Document.Container, for: Any do
+  alias Lexical.Document
 
-  def context_document(%{source_file: %SourceFile{} = source_file}, _) do
-    source_file
+  def context_document(%{document: %Document{} = document}, _) do
+    document
   end
 
   def context_document(%{lsp: lsp_request}, parent_context_document) do
     context_document(lsp_request, parent_context_document)
   end
 
   def context_document(%{text_document: %{uri: uri}}, parent_context_document) do
-    case SourceFile.Store.fetch(uri) do
-      {:ok, source_file} -> source_file
+    case Document.Store.fetch(uri) do
+      {:ok, document} -> document
       _ -> parent_context_document
     end
   end