"use strict"; const {Fragment: _Fragment, jsx: _jsx, jsxs: _jsxs} = arguments[0]; function _createMdxContent(props) { const _components = { a: "a", code: "code", h2: "h2", h3: "h3", h4: "h4", h6: "h6", p: "p", pre: "pre", ...props.components }; return _jsxs(_Fragment, { children: [_jsx(_components.h2, { id: "introduction", children: _jsx(_components.a, { href: "#introduction", children: "Introduction" }) }), "\n", _jsx(_components.p, { children: _jsx(_components.a, { href: "https://github.com/johnotander/nested_attr", children: "For those that only want to see the code." }) }), "\n", _jsxs(_components.p, { children: ["Developing web applications in Rails will inevitably lead to an Active Record ", _jsx(_components.code, { children: "has_many" }), "/", _jsx(_components.code, { children: "has_one" }), " and ", _jsx(_components.code, { children: "belongs_to" }), " relationship. These Active Record associations can produce overly verbose and redundant code that become very difficult to maintain. Luckily, Ruby on Rails provides the ", _jsx(_components.code, { children: "accepts_nested_attributes_for" }), " method that results in the syntactic goodness that we strive for."] }), "\n", _jsxs(_components.p, { children: ["If this relationship isn't accomplished with ", _jsx(_components.code, { children: "accepts_nested_attributes_for" }), ", we result in two undesirable situations:"] }), "\n", _jsx(_components.h3, { id: "a-sloppy-controller", children: _jsx(_components.a, { href: "#a-sloppy-controller", children: "A sloppy controller" }) }), "\n", _jsx(_components.p, { children: "Consider the abstracted new/create actions below:" }), "\n", _jsx(_components.h6, { id: "note-the-parameters-in-the-create-action-may-vary-depending-on-your-form", children: _jsx(_components.a, { href: "#note-the-parameters-in-the-create-action-may-vary-depending-on-your-form", children: "Note: The parameters in the create action may vary, depending on your form." }) }), "\n", _jsx(_components.pre, { children: _jsx(_components.code, { className: "language-ruby", children: "class ParentModelController < ApplicationController\n\n def new\n @parent_model = ParentModel.new\n @child_model = ChildModel.new\n end\n\n def create\n @parent_model = ParentModel.new params[:parent_model]\n @child_model = ChildModel.new params[:child_model]\n @child_model.parent_model = @parent_model\n\n if @parent_model.valid? and @child_model.valid?\n @parent_model.save!\n @child_model.save!\n\n redirect_to parent_models_path\n else\n render :new\n end\n end\nend\n" }) }), "\n", _jsx(_components.p, { children: "As you can see, the controller becomes rather sloppy. Also, as the models change, since they always do, the upkeep becomes unbearable. For example, what happens if we decide to add a ChildToTheChildModel? If this is expected to be created in the same form as the others, we will have an ugly conditional similar to:" }), "\n", _jsx(_components.pre, { children: _jsx(_components.code, { className: "language-ruby", children: "if @parent_model.valid? and @child_model.valid? and @child_to_the_child_model.valid?\n #...\nend\n" }) }), "\n", _jsx(_components.p, { children: "We don't want that." }), "\n", _jsx(_components.h3, { id: "redundant-error-views", children: _jsx(_components.a, { href: "#redundant-error-views", children: "Redundant error views" }) }), "\n", _jsx(_components.p, { children: "Consider error messages, which are typically handled by a block similar to what's below." }), "\n", _jsx(_components.pre, { children: _jsx(_components.code, { className: "language-html+erb", children: "<% if @parent_model.errors.any? %>\n

\n <%= pluralize(@forest.errors.count, \"error\") %> prohibited this ParentModel\n from being saved:\n

\n\n

<%= msg %>

\n<% end %>\n" }) }), "\n", _jsx(_components.p, { children: "We won't be displaying any error messages if all of them occurred on the child_model. So, we will have to violate the DRY principle by adding redundant error handling. Additionally, like the consideration made before, what happens as more dependent models are needed? This view redundancy really begins to exhibit side-effects." }), "\n", _jsx(_components.h2, { id: "taking-advantage-of-accepts_nested_attributes_for", children: _jsx(_components.a, { href: "#taking-advantage-of-accepts_nested_attributes_for", children: "Taking Advantage of accepts_nested_attributes_for" }) }), "\n", _jsxs(_components.p, { children: ["By utilizing the ", _jsx(_components.code, { children: "accepts_nested_attributes_for" }), " method, we can quickly, and efficiently clear up any model dependency code smells. Essentially, all this method does is accept a nested hash of attributes from the form, and assigns them to all the child models that are associated with the parent model. This is achieved by defining a writer on the dependent models."] }), "\n", _jsxs(_components.p, { children: ["Parent => Child => Child to the Child => ... where ", _jsx(_components.code, { children: "child_attributes=(attributes)" }), " and ", _jsx(_components.code, { children: "child_to_the_child_attributes=(attributes)" }), "."] }), "\n", _jsx(_components.p, { children: _jsx(_components.a, { href: "http://api.rubyonrails.org/classes/ActiveRecord/NestedAttributes/ClassMethods.html", children: "ActiveRecord::NestedAttributes::ClassMethods" }) }), "\n", _jsx(_components.h2, { id: "a-forest-that-has_many-trees", children: _jsx(_components.a, { href: "#a-forest-that-has_many-trees", children: "A Forest that has_many Trees" }) }), "\n", _jsxs(_components.p, { children: ["For this example we will use Forest and Tree models where a Tree ", _jsx(_components.code, { children: "belongs_to" }), " a Forest like so:"] }), "\n", _jsx(_components.pre, { children: _jsx(_components.code, { className: "language-ruby", children: "class Forest < ActiveRecord::Base\n has_many :trees, dependent: :destroy\nend\n\nclass Tree < ActiveRecord::Base\n belongs_to :forest\nend\n" }) }), "\n", _jsx(_components.h3, { id: "so-lets-start-a-little-project-to-test-this-out-or-clone-it-on-github", children: _jsxs(_components.a, { href: "#so-lets-start-a-little-project-to-test-this-out-or-clone-it-on-github", children: ["So lets start a little project to test this out (", _jsx(_components.a, { href: "https://github.com/johnotander/nested_attr.git", children: "or clone it on github" }), "):"] }) }), "\n", _jsx(_components.p, { children: "First, create the project." }), "\n", _jsx(_components.p, { children: "$ rails new nested_attributes; cd nested_attributes" }), "\n", _jsx(_components.p, { children: "Then, create a Forest scaffold with some attributes" }), "\n", _jsx(_components.h6, { id: "note-im-not-normally-a-fan-of-utilizing-scaffolds-but-i-will-use-them-here-for-brevitys-sake", children: _jsx(_components.a, { href: "#note-im-not-normally-a-fan-of-utilizing-scaffolds-but-i-will-use-them-here-for-brevitys-sake", children: "note: I'm not normally a fan of utilizing scaffolds, but I will use them here for brevity's sake." }) }), "\n", _jsx(_components.p, { children: "$ rails g scaffold Forest name:string size:integer latitude:integer longitude:integer climate:string" }), "\n", _jsx(_components.p, { children: "Thirdly, create the Tree scaffold." }), "\n", _jsx(_components.p, { children: "$ rails g scaffold Tree common_name:string scientific_name:string forest_id:integer" }), "\n", _jsx(_components.p, { children: "Now, after a migrate, we're ready to get to the code." }), "\n", _jsx(_components.p, { children: "$ bundle exec rake db:migrate" }), "\n", _jsx(_components.h3, { id: "add-nested-attributes-to-the-foresttree-models", children: _jsx(_components.a, { href: "#add-nested-attributes-to-the-foresttree-models", children: "Add Nested Attributes to the Forest/Tree Models" }) }), "\n", _jsxs(_components.p, { children: ["Since the Forest, as the primary(", _jsx(_components.code, { children: "has_many" }), ") model, will be accepting the nested attributes for the dependent Trees, this is the majority of the model logic will live. As you will see below, it is simply three lines of syntactic sugar:"] }), "\n", _jsx(_components.h4, { id: "appmodelsforestrb", children: _jsx(_components.a, { href: "#appmodelsforestrb", children: "app/models/forest.rb" }) }), "\n", _jsx(_components.pre, { children: _jsx(_components.code, { className: "language-ruby", children: "class Forest < ActiveRecord::Base\n has_many :trees\n accepts_nested_attributes_for :trees, allow_destroy: true\n attr_accessible :trees_attributes\n\n attr_accessible :climate, :latitude, :longitude, :name, :size\n\n validates_presence_of :name\n validates_presence_of :size\n validates_presence_of :climate\n validates_presence_of :latitude\n validates_presence_of :longitude\nend\n" }) }), "\n", _jsxs(_components.p, { children: ["The ", _jsx(_components.code, { children: "allow_destroy" }), " parameter ensures that the Forest's Trees will be destroyed along with the Forest itself. If this is desired, the ", _jsx(_components.code, { children: "allow_destroy: true" }), " must be provided, since this functionality is off by default."] }), "\n", _jsx(_components.p, { children: "The Tree model will remain pretty much the same." }), "\n", _jsx(_components.h4, { id: "appmodelstreerb", children: _jsx(_components.a, { href: "#appmodelstreerb", children: "app/models/tree.rb" }) }), "\n", _jsx(_components.pre, { children: _jsx(_components.code, { className: "language-ruby", children: "class Tree < ActiveRecord::Base\n belongs_to :forest\n attr_accessible :common_name, :forest_id, :scientific_name\n\n validates_presence_of :common_name\n validates_presence_of :scientific_name\nend\n" }) }), "\n", _jsx(_components.h3, { id: "build-the-tree-in-the-forest-controller", children: _jsx(_components.a, { href: "#build-the-tree-in-the-forest-controller", children: "Build the Tree in the Forest Controller" }) }), "\n", _jsxs(_components.p, { children: ["The beauty of ", _jsx(_components.code, { children: "accepts_nested_attributes_for" }), " will begin to come out as we dive into the controller. First off, in order to perform standard CRUD on a Forest and it's Trees, all you need is a ", _jsx(_components.code, { children: "ForestController < ApplicationController" }), " since the Trees themselves will be manipulated through the same form. So, all we need to do is instantiate the Forest and a Tree like the ", _jsx(_components.code, { children: "new" }), " action below:"] }), "\n", _jsx(_components.h4, { id: "appcontrollersforests_controllerrb", children: _jsx(_components.a, { href: "#appcontrollersforests_controllerrb", children: "app/controllers/forests_controller.rb" }) }), "\n", _jsx(_components.pre, { children: _jsx(_components.code, { className: "language-ruby", children: "# GET /forests/new\n# GET /forests/new.json\ndef new\n @forest = Forest.new\n @forest.trees.build\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @forest }\n end\nend\n" }) }), "\n", _jsxs(_components.p, { children: ["This will create the instance variable for ", _jsx(_components.code, { children: "@forest" }), " and a dependent Tree, similar to what ", _jsx(_components.code, { children: "@forest.trees << Tree.new" }), " would achieve. Additionally, if you wanted to add three Trees to every Forest, you could replace ", _jsx(_components.code, { children: "@forest.trees.build" }), " with ", _jsx(_components.code, { children: "3.times { |t| @forest.trees.build }" }), ". It's as simple as that."] }), "\n", _jsx(_components.h3, { id: "wire-in-the-views-for-nested-attributes", children: _jsx(_components.a, { href: "#wire-in-the-views-for-nested-attributes", children: "Wire in the Views for Nested Attributes" }) }), "\n", _jsxs(_components.p, { children: ["The first thing I like to do with my forms is to rip out the fields in the form into a ", _jsx(_components.code, { children: "_fields.html.erb" }), " partial. This ends up coming in very handy later on. So, after doing that in the forests directory we end up with:"] }), "\n", _jsx(_components.h4, { id: "appviewsforests_formhtmlerb", children: _jsx(_components.a, { href: "#appviewsforests_formhtmlerb", children: "app/views/forests/_form.html.erb" }) }), "\n", _jsx(_components.pre, { children: _jsx(_components.code, { className: "language-html+erb", children: "<%= form_for(@forest) do |f| %> <% if @forest.errors.any? %>\n

\n <%= pluralize(@forest.errors.count, \"error\") %> prohibited this forest from\n being saved:\n

\n\n

<%= msg %>

\n<% end %> <%= render partial: 'fields', locals: { f: f } %>\n\n

\n <%= f.submit %>\n

\n<% end %>\n" }) }), "\n", _jsx(_components.h4, { id: "appviewsforests_fieldshtmlerb", children: _jsx(_components.a, { href: "#appviewsforests_fieldshtmlerb", children: "app/views/forests/_fields.html.erb" }) }), "\n", _jsx(_components.pre, { children: _jsx(_components.code, { className: "language-html+erb", children: "

\n <%= f.label :name %>
\n <%= f.text_field :name %>\n

\n <%= f.label :size %>
\n <%= f.text_field :size %>\n

\n <%= f.label :latitude %>
\n <%= f.text_field :latitude %>\n

\n <%= f.label :longitude %>
\n <%= f.text_field :longitude %>\n

\n <%= f.label :climate %>
\n <%= f.text_field :climate %>\n

\n" }) }), "\n", _jsxs(_components.p, { children: ["We will also add a ", _jsx(_components.code, { children: "_fields.html.erb" }), " file for Trees."] }), "\n", _jsx(_components.h4, { id: "appviewstrees_fieldshtmlerb", children: _jsx(_components.a, { href: "#appviewstrees_fieldshtmlerb", children: "app/views/trees/_fields.html.erb" }) }), "\n", _jsx(_components.pre, { children: _jsx(_components.code, { className: "language-html+erb", children: "

Tree

\n <%= f.label :common_name %>
\n <%= f.text_field :common_name %>\n

\n <%= f.label :scientific_name %>
\n <%= f.text_field :scientific_name %>\n

\n" }) }), "\n", _jsxs(_components.p, { children: ["Now, we need to render the fields partial for each Tree that belongs to the instantiated Forest. In order to do this, we need to include the following at the bottom of the ", _jsx(_components.code, { children: "app/view/forests/_fields.html.erb" }), " partial:"] }), "\n", _jsx(_components.pre, { children: _jsx(_components.code, { className: "language-html+erb", children: "<%= f.fields_for :trees do |t| %> <%= render partial: 'trees/fields', locals: {\nf: t } %> <% end %>\n" }) }), "\n", _jsxs(_components.p, { children: ["This snippet ensures that the ", _jsx(_components.code, { children: "trees/fields" }), " partial will be rendered for each Tree that belongs to ", _jsx(_components.code, { children: "@forest" }), ". As you can see, we are also passing a local variable with the argument ", _jsx(_components.code, { children: "locals: { f: t }" }), ", which is sending the form builder to the fields partial. Since the ", _jsx(_components.code, { children: "|t|" }), " is part of the ", _jsx(_components.code, { children: "f.fields_for :trees do |t|" }), " block, Rails automagically increments the attributes for each Tree. That way, the parameters that are passed for each Tree are separate, ensuring that a later Tree's attributes in the parameters hash won't overwrite a predecessor."] }), "\n", _jsx(_components.h2, { id: "thats-it", children: _jsx(_components.a, { href: "#thats-it", children: "That's It" }) }), "\n", _jsxs(_components.p, { children: ["Just like that we have implemented a ", _jsx(_components.code, { children: "has_many" }), "/", _jsx(_components.code, { children: "belongs_to" }), " relationship which requires only one controller and only one form view partial for the dependent model, Tree in this case. Pretty clean, pretty simple, absolutely automagical."] }), "\n", _jsxs(_components.p, { children: ["Don't forget to check the ", _jsx(_components.a, { href: "https://github.com/johnotander/nested_attr", children: "source" }), "."] })] }); } function MDXContent(props = {}) { const {wrapper: MDXLayout} = props.components || ({}); return MDXLayout ? _jsx(MDXLayout, { ...props, children: _jsx(_createMdxContent, { ...props }) }) : _createMdxContent(props); } return { default: MDXContent };

Nested Attributes with Rails 3