Add 'module' keyword

Author: mikeygough

lib/ruby_lsp/listeners/hover.rb

@@ -31,6 +31,7 @@ class Hover
         Prism::InstanceVariableOrWriteNode,
         Prism::InstanceVariableTargetNode,
         Prism::InstanceVariableWriteNode,
+        Prism::ModuleNode,
         Prism::SymbolNode,
         Prism::StringNode,
         Prism::InterpolatedStringNode,
@@ -86,6 +87,7 @@ def initialize(response_builder, global_state, uri, node_context, dispatcher, so
           :on_instance_variable_operator_write_node_enter,
           :on_instance_variable_or_write_node_enter,
           :on_instance_variable_target_node_enter,
+          :on_module_node_enter,
           :on_super_node_enter,
           :on_forwarding_super_node_enter,
           :on_string_node_enter,
@@ -153,6 +155,11 @@ def on_for_node_enter(node)
         handle_keyword_documentation(node.for_keyword)
       end
 
+      #: (Prism::ModuleNode node) -> void
+      def on_module_node_enter(node)
+        handle_keyword_documentation(node.module_keyword)
+      end
+
       #: (Prism::InterpolatedStringNode node) -> void
       def on_interpolated_string_node_enter(node)
         generate_heredoc_hover(node)

lib/ruby_lsp/static_docs.rb

@@ -22,6 +22,7 @@ module RubyLsp
     "else" => "Executes the code in the else block if the condition is false",
     "ensure" => "Executes the code in the ensure block regardless of whether an exception is raised or not",
     "for" => "Iterates over a collection of elements",
+    "module" => "Defines a module",
     "yield" => "Invokes the passed block with the given arguments",
   }.freeze #: Hash[String, String]
 end

static_docs/module.md

@@ -0,0 +1,104 @@
+# Module
+
+In Ruby, the `module` keyword creates a container for methods and constants. Modules serve two primary purposes: namespacing related code and providing reusable behavior through mixins.
+
+```ruby
+# Basic module definition
+module Formatter
+  def self.titleize(text)
+    text.split.map(&:capitalize).join(" ")
+  end
+end
+
+puts Formatter.titleize("hello world")
+# Output:
+# Hello World
+```
+
+Modules can be included in classes to share behavior through mixins, allowing for code reuse without inheritance.
+
+```ruby
+# Module as a mixin
+module Printable
+  def print_details
+    puts "Name: #{name}"
+    puts "ID: #{id}"
+  end
+end
+
+class Product
+  include Printable
+  attr_reader :name, :id
+
+  def initialize(name, id)
+    @name = name
+    @id = id
+  end
+end
+
+book = Product.new("Ruby Guide", "B123")
+book.print_details
+# Output:
+# Name: Ruby Guide
+# ID: B123
+```
+
+## Namespacing
+
+Modules help organize code by grouping related classes and methods under a namespace.
+
+```ruby
+module Shop
+  class Product
+    def initialize(name)
+      @name = name
+    end
+  end
+
+  class Order
+    def initialize(product)
+      @product = product
+    end
+  end
+end
+
+# Using namespaced classes
+product = Shop::Product.new("Coffee")
+order = Shop::Order.new(product)
+```
+
+## Multiple Includes
+
+A class can include multiple modules to compose different behaviors.
+
+```ruby
+module Validatable
+  def valid?
+    !name.nil? && !id.nil?
+  end
+end
+
+module Displayable
+  def display
+    "#{name} (#{id})"
+  end
+end
+
+class Item
+  include Validatable
+  include Displayable
+
+  attr_reader :name, :id
+
+  def initialize(name, id)
+    @name = name
+    @id = id
+  end
+end
+
+item = Item.new("Laptop", "L456")
+puts item.valid?    # Output: true
+puts item.display   # Output: Laptop (L456)
+```
+
+The `module` keyword is essential for organizing code and implementing Ruby's version of multiple inheritance through mixins.