Add 'class' keyword

Author: mikeygough

lib/ruby_lsp/listeners/hover.rb

@@ -10,6 +10,7 @@ class Hover
         Prism::BreakNode,
         Prism::CallNode,
         Prism::CaseNode,
+        Prism::ClassNode,
         Prism::ConstantReadNode,
         Prism::ConstantWriteNode,
         Prism::ConstantPathNode,
@@ -58,6 +59,7 @@ def initialize(response_builder, global_state, uri, node_context, dispatcher, so
           self,
           :on_break_node_enter,
           :on_case_node_enter,
+          :on_class_node_enter,
           :on_constant_read_node_enter,
           :on_constant_write_node_enter,
           :on_constant_path_node_enter,
@@ -111,6 +113,11 @@ def on_case_node_enter(node)
         handle_keyword_documentation(node.case_keyword)
       end
 
+      #: (Prism::ClassNode node) -> void
+      def on_class_node_enter(node)
+        handle_keyword_documentation(node.class_keyword)
+      end
+
       #: (Prism::InterpolatedStringNode node) -> void
       def on_interpolated_string_node_enter(node)
         generate_heredoc_hover(node)

lib/ruby_lsp/static_docs.rb

@@ -16,6 +16,7 @@ module RubyLsp
   KEYWORD_DOCS = {
     "break" => "Terminates the execution of a block, loop, or method",
     "case" => "Starts a case expression for pattern matching or multiple condition checking",
+    "class" => "Defines a class and its methods",
     "yield" => "Invokes the passed block with the given arguments",
   }.freeze #: Hash[String, String]
 end

static_docs/class.md

@@ -0,0 +1,137 @@
+# Class
+
+In Ruby, a `class` is a blueprint for creating objects that share similar attributes and behaviors. Classes encapsulate data and methods, following object-oriented programming principles.
+
+```ruby
+# Basic class definition
+class Person
+  def initialize(name)
+    @name = name
+  end
+
+  def greet
+    puts "Hello, #{@name}!"
+  end
+end
+
+person = Person.new("Ruby")
+person.greet
+# Output:
+# Hello, Ruby!
+```
+
+Classes can include instance methods, class methods, and various types of variables.
+
+```ruby
+class Product
+  # Class variable (shared across all instances)
+  @@count = 0
+
+  # Class method
+  def self.count
+    @@count
+  end
+
+  def initialize(name, price)
+    @name = name
+    @price = price
+    @@count += 1
+  end
+
+  # Instance method
+  def details
+    "#{@name}: $#{@price}"
+  end
+end
+
+book = Product.new("Ruby Guide", 29.99)
+puts Product.count # Output: 1
+puts book.details # Output: Ruby Guide: $29.99
+```
+
+## Inheritance
+
+Classes can inherit behavior from other classes using the `<` operator. A class can only inherit from one parent class.
+
+```ruby
+# Parent class
+class Animal
+  def speak
+    "Some sound"
+  end
+end
+
+# Child class
+class Dog < Animal
+  def speak
+    "Woof!"
+  end
+end
+
+dog = Dog.new
+puts dog.speak # Output: Woof!
+```
+
+## Access Control
+
+Ruby provides three levels of method access control: `public`, `private`, and `protected`.
+
+```ruby
+class BankAccount
+  def initialize(balance)
+    @balance = balance
+  end
+
+  # Public method - can be called by anyone
+  def display_balance
+    "Current balance: $#{@balance}"
+  end
+
+  # Protected method - can be called by other instances
+  protected
+
+  def compare_balance(other)
+    @balance > other.balance
+  end
+
+  # Private method - can only be called internally
+  private
+
+  def update_balance(amount)
+    @balance += amount
+  end
+end
+
+account = BankAccount.new(100)
+puts account.display_balance
+# Output: Current balance: $100
+```
+
+## Class Instance Variables
+
+Instance variables can be exposed using attribute accessors. Ruby provides several methods to create them.
+
+```ruby
+class User
+  # Create reader and writer methods
+  attr_accessor :name
+
+  # Create reader only
+  attr_reader :created_at
+
+  # Create writer only
+  attr_writer :password
+
+  def initialize(name)
+    @name = name
+    @created_at = Time.now
+  end
+end
+
+user = User.new("Alice")
+puts user.name # Output: Alice
+user.name = "Bob"
+puts user.name # Output: Bob
+```
+
+The `class` keyword is fundamental to Ruby's object-oriented nature, allowing you to create organized, reusable, and maintainable code through encapsulation, inheritance, and polymorphism.