chore: Update Couchbase ORM documentation for Ruby tutorial

Author: teetangh

docusaurus/docs/tutorial-ruby-couchbase-orm/01-introduction.md

@@ -4,7 +4,7 @@ sidebar_position: 01
 
 # Introduction
 
-Welcome to the documentation for Couchbase ORM, a powerful Object-Relational Mapping (ORM) library for Ruby that simplifies interactions with Couchbase Server. This guide will walk you through the features and usage of Couchbase ORM, helping you build efficient and scalable Ruby applications with Couchbase.
+Welcome to the documentation for Couchbase ORM, a Object-Relational Mapping (ORM) library for Ruby that simplifies interactions with Couchbase Server. This guide will walk you through the features and usage of Couchbase ORM, helping you build efficient and scalable Ruby applications with Couchbase.
 
 ## 1.1. What is Couchbase ORM?
 

docusaurus/docs/tutorial-ruby-couchbase-orm/04-querying.md

@@ -55,24 +55,7 @@ users = User.order(age: :desc)
 
 You can also chain multiple `order` clauses to sort by multiple attributes.
 
-## 4.4. Limit and Offset
-
-<!-- TODO: Have to implement this -->
-
-To limit the number of records returned or to skip a certain number of records, you can use the `limit` and `offset` methods.
-
-```ruby
-# Find the first 10 users
-users = User.limit(10)
-
-# Find users starting from the 11th record
-users = User.offset(10)
-
-# Find users starting from the 11th record and limit to 10 records
-users = User.offset(10).limit(10)
-```
-
-## 4.5. Scopes
+## 4.4. Scopes
 
 Scopes allow you to define reusable query snippets that can be chained with other query methods. Scopes are defined as class methods within your model.
 
@@ -88,7 +71,7 @@ users = User.active.adults
 
 Scopes provide a clean and DRY way to encapsulate commonly used query conditions.
 
-## 4.6. Pluck
+## 4.5. Pluck
 
 The `pluck` method allows you to retrieve specific attributes from the matched records instead of loading the entire objects. It returns an array of values for the specified attributes.
 
@@ -100,7 +83,7 @@ names = User.pluck(:name)
 name_emails = User.active.pluck(:name, :email)
 ```
 
-## 4.7. Destroy All
+## 4.6. Destroy All
 
 To delete multiple records that match specific conditions, you can use the `destroy_all` method.
 

docusaurus/docs/tutorial-ruby-couchbase-orm/05-persistence.md

@@ -71,29 +71,7 @@ user.update(name: 'John Doe', age: 30)
 
 The `update` method updates only the specified attributes of the record in the database.
 
-## 5.6. Atomic Operations
-
-CouchbaseOrm supports atomic operations, which allow you to perform certain database operations in a single, indivisible step. Atomic operations ensure data consistency and help avoid race conditions in concurrent environments.
-
-Some common atomic operations include:
-
-- `increment`: Atomically increments a numeric attribute by a specified value.
-- `decrement`: Atomically decrements a numeric attribute by a specified value.
-- `append`: Atomically appends a value to a string attribute.
-- `prepend`: Atomically prepends a value to a string attribute.
-- `touch`: Updates the document's expiration time without modifying its content.
-
-Here's an example of using atomic operations:
-
-```ruby
-user = User.find('user_id_123')
-user.increment(:login_count)
-user.touch(expiry: 1.hour.from_now)
-```
-
-In this example, the `increment` operation atomically increments the `login_count` attribute of the user, and the `touch` operation updates the document's expiration time to one hour from now.
-
-## 5.7. Callbacks
+## 5.6. Callbacks
 
 As mentioned in the previous section on defining models, CouchbaseOrm supports lifecycle callbacks that allow you to execute code at certain points in a record's persistence lifecycle.
 
@@ -119,23 +97,3 @@ end
 In this example, the `encrypt_password` callback is executed before saving a user record, encrypting the password if it has been changed. The `send_welcome_email` callback is executed after creating a new user record, sending a welcome email to the user.
 
 Callbacks provide a way to encapsulate and reuse common logic related to the persistence lifecycle of your records.
-
-## 5.8. Transactions
-
-CouchbaseOrm supports transactions, which allow you to group multiple database operations into a single, atomic unit of work. Transactions ensure that all the operations within the transaction either succeed together or fail together, maintaining data integrity.
-
-```ruby
-CouchbaseOrm.transaction do
-  user = User.create(name: 'John')
-  account = Account.create(user: user, balance: 100)
-  # ...
-end
-```
-
-In this example, the creation of a user and an associated account are wrapped inside a transaction. If any operation within the transaction fails, all the changes made within the transaction will be rolled back, ensuring that the database remains in a consistent state.
-
-Transactions are useful when you need to perform multiple related operations that should succeed or fail together, such as creating related records or updating multiple documents atomically.
-
-That covers the basics of persistence with CouchbaseOrm. With these methods and features, you can easily create, update, delete, and manipulate records in Couchbase Server using a simple and expressive API.
-
-In the next section, we'll explore the powerful associations feature of CouchbaseOrm, which allows you to define and work with relationships between your models.