`_ *for details)*
-
- Open the ``Comment`` model file, ``app/models/comment.rb``, and change the
- generated ``embedded_in`` association to ``belongs_to``:
-
- .. code-block:: ruby
- :caption: app/models/comment.rb
-
- class Comment
- include Mongoid::Document
-
- field :name, type: String
- field :message, type: String
-
- belongs_to :post
- end
-
-Open the post show view file, ``app/views/posts/show.html.erb``, and add
-a section rendering existing comments and prompting to leave a new comment:
-
-.. code-block:: html
- :caption: app/views/posts/show.html.erb
-
-
-
-Open the comment form file and change the type of field for ``:message``
-from ``text_field`` to ``text_area``, as well as the type of field for
-``:post_id`` from ``text_field`` to ``hidden_field``. The result
-should look like this:
-
-.. code-block:: html
- :caption: app/views/comments/_form.html.erb
-
- <%= form_with(model: comment, local: true) do |form| %>
- <% if comment.errors.any? %>
-
-
<%= pluralize(comment.errors.count, "error") %> prohibited this comment from being saved:
-
-
- <% comment.errors.full_messages.each do |message| %>
- - <%= message %>
- <% end %>
-
-
- <%= form.label :name %>
- <%= form.text_field :name %>
-
-
-
- <%= form.label :message %>
- <%= form.text_area :message %>
-
-
-
- <%= form.hidden_field :post_id %>
-
-
-
- <%= form.submit %>
-
- <% end %>
-
-Create a partial for the comment view, ``app/views/comments/_comment.html.erb``
-with the following contents:
-
-.. code-block:: html
- :caption: app/views/comments/_comment.html.erb
-
-
- <%= comment.name %>:
- <%= comment.message %>
-
- <%= link_to 'Delete', [comment],
- method: :delete,
- class: "button is-danger",
- data: { confirm: 'Are you sure?' } %>
-
-
-You should now be able to leave comments for the posts:
-
-.. image:: ../img/rails-blog-new-comment.png
- :alt: Screenshot of the blog with a new comment being added
-
-Existing Application
---------------------
-
-Follow these steps to switch an existing Ruby on Rails application to use
-Mongoid instead of ActiveRecord.
-
-Dependencies
-~~~~~~~~~~~~
-
-Remove or comment out any RDBMS libraries like ``sqlite``, ``pg`` etc.
-mentioned in ``Gemfile``, and add ``mongoid``:
-
-.. code-block:: ruby
- :caption: Gemfile
-
- gem 'mongoid'
-
-.. note::
-
- Mongoid 7.0.5 or higher is required to use Rails 6.0.
-
-Install gem dependencies:
-
-.. code-block:: sh
-
- bundle install
-
-Loaded Frameworks
-~~~~~~~~~~~~~~~~~
-
-Examine ``config/application.rb``. If it is requiring all components of Rails
-via ``require 'rails/all'``, change it to require individual frameworks:
-
-.. code-block:: ruby
- :caption: config/application.rb
-
- # Remove or comment out
- #require "rails/all"
-
- # Add this require instead of "rails/all":
- require "rails"
-
- # Pick the frameworks you want:
- require "active_model/railtie"
- require "active_job/railtie"
- require "action_controller/railtie"
- require "action_mailer/railtie"
- # require "action_mailbox/engine"
- # require "action_text/engine"
- require "action_view/railtie"
- require "action_cable/engine"
- require "sprockets/railtie"
- require "rails/test_unit/railtie"
-
- # Remove or comment out ActiveRecord and ActiveStorage:
- # require "active_record/railtie"
- # require "active_storage/engine"
-
-.. note::
-
- At this time ActiveStorage requires ActiveRecord and is not usable with
- Mongoid.
-
-ActiveRecord Configuration
-~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-Review all configuration files (``config/application.rb``,
-``config/environments/{development,production.test}.rb``) and remove or
-comment out any references to ``config.active_record`` and
-``config.active_storage``.
-
-Stop Spring
-~~~~~~~~~~~
-
-If your application is using Spring, which is the default on Rails 6,
-Spring must be stopped after changing dependencies or configuration.
-
-.. code-block:: sh
-
- ./bin/spring stop
-
-.. note::
-
- Sometimes running ``./bin/spring stop`` claims to stop Spring, but does
- not. Verify that all Spring processes are terminated before proceeding.
-
-.. note::
-
- Sometimes Spring tries to load ActiveRecord even when the application
- contains no ActiveRecord references. If this happens, add an ActiveRecord
- adapter dependency such as ``sqlite3`` to your ``Gemfile`` so that
- ActiveRecord may be completely loaded or remove Spring from your
- application.
-
-Mongoid Configuration
-~~~~~~~~~~~~~~~~~~~~~
-
-Generate the default Mongoid configuration:
-
-.. code-block:: sh
-
- bin/rails g mongoid:config
-
-This generator will create the ``config/mongoid.yml`` configuration file
-(used to configure the connection to the MongoDB deployment) and the
-``config/initializers/mongoid.rb`` initializer file (which may be used for
-other Mongoid-related configuration). In general, it is recommended to use
-``mongoid.yml`` for all Mongoid configuration.
-
-Review the sections :ref:`Run MongoDB Locally ` and
-:ref:`Use MongoDB Atlas ` to decide how you would like to deploy
-MongoDB, and adjust Mongoid configuration (``config/mongoid.yml``) to match.
-
-Adjust Models
-~~~~~~~~~~~~~
-
-If your application already has models, these will need to be changed when
-migrating from ActiveRecord to Mongoid.
-
-ActiveRecord models derive from ``ApplicationRecord`` and do not have
-column definitions. Mongoid models generally have no superclass but must
-include ``Mongoid::Document``, and usually define the fields explicitly
-(but :ref:`dynamic fields ` may also be used instead of
-explicit field definitions).
-
-For example, a bare-bones Post model may look like this in ActiveRecord:
-
-.. code-block:: ruby
- :caption: app/models/post.rb
-
- class Post < ApplicationRecord
- has_many :comments, dependent: :destroy
- end
-
-The same model may look like this in Mongoid:
-
-.. code-block:: ruby
- :caption: app/models/post.rb
-
- class Post
- include Mongoid::Document
-
- field :title, type: String
- field :body, type: String
-
- has_many :comments, dependent: :destroy
- end
-
-Or like this with dynamic fields:
-
-.. code-block:: ruby
- :caption: app/models/post.rb
-
- class Post
- include Mongoid::Document
- include Mongoid::Attributes::Dynamic
-
- has_many :comments, dependent: :destroy
- end
-
-Mongoid does not utilize ActiveRecord migrations, since MongoDB does not
-require a schema to be defined prior to storing data.
-
-Data Migration
-~~~~~~~~~~~~~~
-
-If you already have data in a relational database that you would like to
-transfer to MongoDB, you will need to perform a data migration. As noted
-above, no schema migration is necessary because MongoDB does not require
-a predefined schema to store the data.
-
-The migration tools are often specific to the data being migrated because,
-even though Mongoid supports a superset of ActiveRecord associations,
-the way that model references are stored in collections differs between
-Mongoid and ActiveRecord. With that said, MongoDB has
-some resources on migrating from an RDBMS to MongoDB such as the
-`RDBMS to MongoDB Migration Guide `_ and
-`Modernization Guide `_.
-
-Rails API
-~~~~~~~~~
-
-The process for creating a Rails API application with Mongoid is the same
-as when creating a regular application, with the only change being the
-``--api`` parameter to ``rails new``. Migrating a Rails API application to
-Mongoid follows the same process described above for regular Rails applications.
-
-A complete Rails API application similar to the one described in this tutorial
-can be found in `the mongoid-demo GitHub repository
-`_.
diff --git a/source/tutorials/getting-started-rails7.txt b/source/tutorials/getting-started-rails7.txt
deleted file mode 100644
index 9e7c282d..00000000
--- a/source/tutorials/getting-started-rails7.txt
+++ /dev/null
@@ -1,471 +0,0 @@
-.. _getting-started-7:
-
-*************************
-Getting Started (Rails 7)
-*************************
-
-.. default-domain:: mongodb
-
-.. contents:: On this page
- :local:
- :backlinks: none
- :depth: 2
- :class: singlecol
-
-.. note::
-
- This tutorial is for Ruby on Rails 7. If this is not the version
- you're using, choose the appropriate tutorial for your Rails version
- from the navigation menu.
-
-New Application
-===============
-
-This section demonstrates how to create a new Ruby on Rails application using the Mongoid ODM.
-By replacing Rails' default `ActiveRecord `_
-adapter with MongoDB's ORM-like library for data access we will create an application similar to the
-blog application described in the `Ruby on Rails Getting Started
-`_ guide.
-
-The complete source code for this application can be found in the
-`mongoid-demo GitHub repository
-`_.
-
-.. note::
-
- This guide assumes basic familiarity with Ruby on Rails.
- To learn more about Ruby on Rails, please refer to its `Getting Started
- guide `_ or
- other Rails guides.
-
-
-Install ``rails``
------------------
-
-We will use a Rails generator to create the application skeleton.
-In order to do so, the first step is to install the ``rails`` gem:
-
-.. code-block:: sh
-
- gem install rails -v {+rails-7-version+}
-
-
-Create New Application
-----------------------
-
-Use the ``rails`` command to create the application skeleton, as follows:
-
-.. code-block:: sh
-
- rails new blog --skip-active-record
- cd blog
-
-We pass ``--skip-active-record`` to request that ActiveRecord is not added
-as a dependency, because we will be using Mongoid instead.
-
-Optionally Skip Tests
-`````````````````````
-
-If you intend to test your application with `RSpec `_, you can instruct the
-generator to omit the default Rails test setup by passing ``--skip-test``
-and ``--skip-system-test`` options:
-
-.. code-block:: sh
-
- rails new blog --skip-active-record --skip-test --skip-system-test
- cd blog
-
-Setup Mongoid
--------------
-
-1. Modify the ``Gemfile`` to add a reference to the
-`mongoid `_ gem:
-
-.. code-block:: ruby
- :caption: Gemfile
-
- gem 'mongoid'
-
-2. Install gem dependencies:
-
-.. code-block:: sh
-
- bundle install
-
-3. Generate the default `Mongoid configuration `_:
-
-.. code-block:: sh
-
- bin/rails g mongoid:config
-
-This generator will create the ``config/mongoid.yml`` configuration file
-(used to configure the connection to the MongoDB deployment) and the
-``config/initializers/mongoid.rb`` initializer file (which may be used for
-other Mongoid-related configuration). Note that as we are not using
-ActiveRecord we will not have a ``database.yml`` file.
-
-
-.. _configure-self-managed:
-
-Configure for Self Managed MongoDB
-``````````````````````````````````
-
-The configuration created in the previous step is suitable when
-a MongoDB server is running locally. If you do not already have a
-local MongoDB server, `download and install MongoDB
-`_.
-
-While the generated ``mongoid.yml`` will work without modifications,
-we recommend reducing the server selection timeout for development.
-With this change, the uncommented lines of ``mongoid.yml`` should look
-like this:
-
-.. code-block:: yaml
-
- development:
- clients:
- default:
- database: blog_development
- hosts:
- - localhost:27017
- options:
- server_selection_timeout: 1
-
-
-.. _configure-atlas:
-
-Configure for MongoDB Atlas
-```````````````````````````
-
-Instead of downloading, installing and running MongoDB locally, you can create
-a free MongoDB Atlas account and create a `free MongoDB cluster in Atlas
-`_.
-Once the cluster is created, follow the instructions in `connect to the cluster
-page `_
-to obtain the URI. Use the *Ruby driver 2.5 or later* format.
-
-Paste the URI into the ``config/mongoid.yml`` file, and comment out the
-hosts that are defined. We recommend setting the server selection timeout to 5
-seconds for development environment when using Atlas.
-
-The uncommented contents of ``config/mongoid.yml`` should look like this:
-
-.. code-block:: yaml
-
- development:
- clients:
- default:
- uri: mongodb+srv://user:pass@yourcluster.mongodb.net/blog_development?retryWrites=true&w=majority
- options:
- server_selection_timeout: 5
-
-Run Application
----------------
-
-You can now start the application server by running:
-
-.. code-block:: sh
-
- bin/rails s
-
-Access the application by navigating to `localhost:3000
-`_.
-
-
-Add Posts
----------
-
-Using the standard Rails scaffolding, Mongoid can generate the necessary
-model, controller and view files for our blog so that we can quickly begin
-creating blog posts:
-
-.. code-block:: sh
-
- bin/rails g scaffold Post title:string body:text
-
-Navigate to `localhost:3000/posts `_
-to create posts and see the posts that have already been created.
-
-.. figure:: /img/rails-new-blog.png
- :alt: Screenshot of the new blog
-
-
-Add Comments
-------------
-
-To make our application more interactive, let's add the ability for users to
-add comments to our posts.
-
-Create the ``Comment`` model:
-
-.. code-block:: sh
-
- bin/rails g scaffold Comment name:string message:string post:belongs_to
-
-Open the ``Post`` model file, ``app/models/post.rb``, and add a ``has_many``
-association for the comments:
-
-.. code-block:: ruby
- :caption: app/models/post.rb
-
- class Post
- include Mongoid::Document
- include Mongoid::Timestamps
- field :title, type: String
- field :body, type: String
-
- has_many :comments, dependent: :destroy
- end
-
-Open ``app/views/posts/show.html.erb`` and add
-a section rendering existing comments and prompting to leave a new comment:
-
-.. code-block:: erb
- :caption: app/views/posts/show.html.erb
-
-
-
-Open ``app/views/comments/_form.html.erb`` and change the type of field for ``:message``
-from ``text_field`` to ``text_area``, as well as the type of field for
-``:post_id`` from ``text_field`` to ``hidden_field``. The result
-should look like this:
-
-.. code-block:: erb
- :caption: app/views/comments/_form.html.erb
-
- <%= form_with(model: comment, local: true) do |form| %>
- <% if comment.errors.any? %>
-
-
<%= pluralize(comment.errors.count, "error") %> prohibited this comment from being saved:
-
-
- <% comment.errors.full_messages.each do |message| %>
- - <%= message %>
- <% end %>
-
-
- <%= form.label :name %>
- <%= form.text_field :name %>
-
-
-
- <%= form.label :message %>
- <%= form.text_area :message %>
-
-
-
- <%= form.hidden_field :post_id %>
-
-
-
- <%= form.submit %>
-
- <% end %>
-
-Next replace ``app/view/comments/_comment.html.erb`` with the following contents:
-
-.. code-block:: erb
- :caption: app/views/comments/_comment.html.erb
-
-
- <%= comment.name %>:
- <%= comment.message %>
- <%= link_to 'Delete', [comment],
- data: {
- "turbo-method": :delete,
- "turbo-confirm": 'Are you sure?'
- } %>
-
-
-
-You should now be able to leave comments for the posts:
-
-.. figure:: /img/rails-blog-new-comment.png
- :alt: Screenshot of the blog with a new comment being added
-
-
-Existing Application
-====================
-
-Mongoid can be easily added to an existing Rails application and run alongside other ActiveRecord
-adapters. If this is your use case, updating dependencies and populating the configuration file will
-allow you to start using MongoDB within your application.
-
-To switch an existing Ruby on Rails application to use Mongoid instead of ActiveRecord additional
-configuration changes will be required, as described below.
-
-Dependencies
-------------
-
-First, the ``mongoid`` gem will need to be added your ``Gemfile``.
-
-.. code-block:: ruby
- :caption: Gemfile
-
- gem 'mongoid'
-
-If Mongoid will be the **only** database adapter, remove or comment out any RDBMS libraries
-like ``sqlite`` or ``pg`` mentioned in the ``Gemfile``.
-
-Install gem dependencies:
-
-.. code-block:: sh
-
- bundle install
-
-Mongoid Configuration
----------------------
-
-Generate the default Mongoid configuration:
-
-.. code-block:: sh
-
- bin/rails g mongoid:config
-
-This generator will create the ``config/mongoid.yml`` configuration file
-(used to configure the connection to the MongoDB deployment) and the
-``config/initializers/mongoid.rb`` initializer file (which may be used for
-other Mongoid-related configuration). In general, it is recommended to use
-``mongoid.yml`` for all Mongoid configuration.
-
-Review the sections :ref:`Configure for Self Managed MongoDB `
-and :ref:`Configure for MongoDB Atlas ` to decide how you
-would like to deploy MongoDB, and adjust the Mongoid configuration
-(``config/mongoid.yml``) to match.
-
-Loaded Frameworks
------------------
-
-Examine ``config/application.rb``. If it is requiring all components of Rails
-via ``require 'rails/all'``, change it to require individual frameworks. To verify the contents of
-``rails/all`` for your version see the `Github Repository
-`_:
-
-.. code-block:: ruby
- :caption: config/application.rb
-
- # Remove or comment out
- #require "rails/all"
-
- # Add the following instead of "rails/all":
- require "rails"
-
- # require "active_record/railtie" rescue LoadError
- # require "active_storage/engine" rescue LoadError
- require "action_controller/railtie" rescue LoadError
- require "action_view/railtie" rescue LoadError
- require "action_mailer/railtie" rescue LoadError
- require "active_job/railtie" rescue LoadError
- require "action_cable/engine" rescue LoadError
- # require "action_mailbox/engine" rescue LoadError
- # require "action_text/engine" rescue LoadError
- require "rails/test_unit/railtie" rescue LoadError
-
-.. warning::
-
- Due to their reliance on ActiveRecord, `ActionText `_,
- `ActiveStorage `_ and
- `ActionMailbox `_ cannot be used
- with Mongoid.
-
-ActiveRecord Configuration
---------------------------
-
-Review all configuration files (``config/application.rb``,
-``config/environments/{development,production.test}.rb``) and remove or
-comment out any references to ``config.active_record`` and
-``config.active_storage``.
-
-Adjust Models
--------------
-
-If your application already has models, these will need to be changed when
-migrating from ActiveRecord to Mongoid.
-
-ActiveRecord models derive from ``ApplicationRecord`` and do not have
-column definitions. Mongoid models generally have no superclass but must
-include ``Mongoid::Document``, and usually define the fields explicitly
-(but :ref:`dynamic fields ` may also be used instead of
-explicit field definitions).
-
-For example, a bare-bones Post model may look like this in ActiveRecord:
-
-.. code-block:: ruby
- :caption: app/models/post.rb
-
- class Post < ApplicationRecord
- has_many :comments, dependent: :destroy
- end
-
-The same model may look like this in Mongoid:
-
-.. code-block:: ruby
- :caption: app/models/post.rb
-
- class Post
- include Mongoid::Document
-
- field :title, type: String
- field :body, type: String
-
- has_many :comments, dependent: :destroy
- end
-
-Or like this with dynamic fields:
-
-.. code-block:: ruby
- :caption: app/models/post.rb
-
- class Post
- include Mongoid::Document
- include Mongoid::Attributes::Dynamic
-
- has_many :comments, dependent: :destroy
- end
-
-Mongoid does not utilize ActiveRecord migrations, since MongoDB does not
-require a schema to be defined prior to storing data.
-
-Data Migration
---------------
-
-If you already have data in a relational database that you would like to
-transfer to MongoDB, you will need to perform a data migration. As noted
-above, no schema migration is necessary because MongoDB does not require
-a predefined schema to store the data.
-
-The migration tools are often specific to the data being migrated because,
-even though Mongoid supports a superset of ActiveRecord associations,
-the way that model references are stored in collections differs between
-Mongoid and ActiveRecord. With that said, MongoDB has
-some resources on migrating from an RDBMS to MongoDB such as the
-`RDBMS to MongoDB Migration Guide `_ and
-`Modernization Guide `_.
-
-
-Rails API
----------
-
-The process for creating a Rails API application with Mongoid is the same
-as when creating a regular application, with the only change being the
-``--api`` parameter to ``rails new``. Migrating a Rails API application to
-Mongoid follows the same process described above for regular Rails applications.
-
-A complete Rails API application similar to the one described in this tutorial
-can be found in `the mongoid-demo GitHub repository
-`_.
diff --git a/source/tutorials/getting-started-sinatra.txt b/source/tutorials/getting-started-sinatra.txt
deleted file mode 100644
index 832dd0d6..00000000
--- a/source/tutorials/getting-started-sinatra.txt
+++ /dev/null
@@ -1,220 +0,0 @@
-.. _getting-started-sinatra:
-
-*************************
-Getting Started (Sinatra)
-*************************
-
-.. default-domain:: mongodb
-
-.. contents:: On this page
- :local:
- :backlinks: none
- :depth: 2
- :class: singlecol
-
-
-New Application
-===============
-
-This section shows how to create a new Sinatra application using Mongoid
-for data access. The process is similar for other Ruby applications not
-using Ruby on Rails.
-
-The complete source code for this application is available `in the
-mongoid-demo GitHub repository
-`_.
-
-Create Git Repo
----------------
-
-While not required, we recommend creating a Git repository for your application:
-
-.. code-block:: sh
-
- git init blog
- cd blog
-
-Commit your changes as you are following this tutorial.
-
-
-Create Gemfile
---------------
-
-Create a file named ``Gemfile`` with the following contents:
-
-.. code-block:: ruby
-
- source 'https://rubygems.org'
-
- gem 'sinatra'
- gem 'mongoid'
- gem 'puma'
-
-
-Install Dependencies
---------------------
-
-Run the following commands to install the dependencies:
-
-.. code-block:: sh
-
- gem install bundler
- bundle install
-
-This command will generate a file named ``Gemfile.lock`` which we recommend
-committing to your Git repository.
-
-
-Run MongoDB Locally
--------------------
-
-To develop locally with MongoDB, `download and install MongoDB
-`_.
-
-Once MongoDB is installed and running, create a file named ``config/mongoid.yml``
-pointing to your deployment. For example, if you launched a standalone
-``mongod`` on the default port, the following contents would be appropriate:
-
-.. code-block:: none
-
- development:
- clients:
- default:
- database: blog_development
- hosts:
- - localhost:27017
- options:
- server_selection_timeout: 1
-
-
-Use MongoDB Atlas
------------------
-
-Instead of downloading, installing and running MongoDB locally, you can create
-a free MongoDB Atlas account and create a `free MongoDB cluster in Atlas
-`_.
-Once the cluster is created, follow the instructions in `connect to the cluster
-page `_
-to obtain the URI. Use the *Ruby driver 2.5 or later* format.
-
-Create a file named ``config/mongoid.yml`` with the following
-contents, replacing the URI with the actual URI for your cluster:
-
-.. code-block:: yaml
-
- development:
- clients:
- default:
- uri: mongodb+srv://user:pass@yourcluster.mongodb.net/blog_development?retryWrites=true&w=majority
- options:
- server_selection_timeout: 5
-
-
-
-Basic Application
------------------
-
-Create a file named ``app.rb`` with the following contents. First, some
-requires:
-
-.. code-block:: ruby
-
- require 'sinatra'
- require 'mongoid'
-
-Load the Mongoid configuration file and configure Mongoid. This is done
-automatically when Mongoid is used with Rails, but since we are using Mongoid
-with Sinatra, we need to do this ourselves:
-
-.. code-block:: ruby
-
- Mongoid.load!(File.join(File.dirname(__FILE__), 'config', 'mongoid.yml'))
-
-Now we can define some models:
-
-.. code-block:: ruby
-
- class Post
- include Mongoid::Document
-
- field :title, type: String
- field :body, type: String
-
- has_many :comments
- end
-
- class Comment
- include Mongoid::Document
-
- field :name, type: String
- field :message, type: String
-
- belongs_to :post
- end
-
-... and add some routes:
-
-.. code-block:: ruby
-
- get '/posts' do
- Post.all.to_json
- end
-
- post '/posts' do
- post = Post.create!(params[:post])
- post.to_json
- end
-
- get '/posts/:post_id' do |post_id|
- post = Post.find(post_id)
- post.attributes.merge(
- comments: post.comments,
- ).to_json
- end
-
- post '/posts/:post_id/comments' do |post_id|
- post = Post.find(post_id)
- comment = post.comments.create!(params[:comment])
- {}.to_json
- end
-
-
-Run Application
-===============
-
-Launch the application:
-
-.. code-block:: sh
-
- bundle exec ruby app.rb
-
-Try some requests via curl:
-
-.. code-block:: sh
-
- curl http://localhost:4567/posts
- # => []
-
- curl -d 'post[title]=hello&post[body]=hello+world' http://localhost:4567/posts
- # => {"_id":{"$oid":"5d8151ec96fb4f0ed5a7a03f"},"body":"hello world","title":"hello"}
-
- curl http://localhost:4567/posts
- # => [{"_id":{"_id":{"$oid":"5d8151ec96fb4f0ed5a7a03f"},"body":"hello world","title":"hello"}]
-
- curl -d 'comment[name]=David&comment[message]=I+like' http://localhost:4567/posts/5d8151ec96fb4f0ed5a7a03f/comments
- # => {}
-
- curl http://localhost:4567/posts/5d8151ec96fb4f0ed5a7a03f
- # => {"_id":{"$oid":"5d8151ec96fb4f0ed5a7a03f"},"title":"hello","body":"hello world","comments":[{"_id":{"$oid":"5d8157ac96fb4f20c5e45c4d"},"message":"I like","name":"David","post_id":{"$oid":"5d8151ec96fb4f0ed5a7a03f"}}]}
-
-
-Existing Application
-====================
-
-To start using Mongoid in an existing Sinatra applications, the steps are
-essentially the same as the one given above for a new application:
-
-1. Add the ``mongoid`` dependency to the ``Gemfile``.
-2. Create a ``mongoid.yml`` configuration file.
-3. Load the configuration file and configure Mongoid in the application.
-4. Define Mongoid models.
-
Leave a reply
- <%= render partial: 'comments/form', locals: { comment: @post.comments.build } %> -