Forem: nadia4206

Work smarter, not harder (how to use the "rails g resource" command)

nadia4206 — Mon, 06 Mar 2023 13:44:30 +0000

Ruby on Rails is a popular web application framework that simplifies web development by providing a set of conventions and tools. One of the most powerful features of Rails is the ability to generate code quickly using the built-in generators. In this blog, we will focus on the rails g resource command, which generates a set of files for a new resource in your application.

A resource in Rails is a representation of a model, controller, and views that work together to provide CRUD (Create, Read, Update, Delete) functionality for a specific type of object. For example, if you were building a blog application, you might have a resource for posts, which would include a Post model, a Posts controller, and views for displaying, editing, and creating posts.

To use the rails g resource command, you'll need to open up your terminal and navigate to the root directory of your Rails application. From there, you can run the command followed by the name of your resource, like this:

rails g resource Post

You can also define the details of your table directly in the terminal. The type "string" is inferred, so those datatypes do not need to be defined:

rails g resource Post title content author likes:integer

This will generate a set of files for the Post resource, including:

A migration file: This file is used to create the database table for the Post model. The migration includes columns for the various attributes of a post, such as title, content, author, and likes.

A model file: This file defines the Post class, which inherits from ActiveRecord::Base. It also includes validations and associations with other models, if applicable.

A controller file: This file defines the PostsController class, which handles HTTP requests and responses for the Post resource. It includes methods for creating, reading, updating, and deleting posts.

Views: The generator creates views for the various actions of the PostsController, such as index, show, create, update, and destroy.

A serializer file: if you have the serializer gem installed, the rails g resource command will also generate a corresponding serializer file.

Once the generator has finished running, you can run migrations to create the Post table in your database:

rails db:migrate

And that's it! You now have a fully functional resource for Posts in your Rails application. Of course, you'll need to customize the generated files to fit your specific requirements, but this generator can save you a lot of time and effort in setting up the basic structure of your application.

Happy coding 💻

💎 How to use the Ruby Faker Gem 💎

nadia4206 — Mon, 13 Feb 2023 14:00:53 +0000

What is the Ruby Faker Gem? It's a handy little tool that allows you to be able to easily create as much dummy data as you need to test out your methods. You can use this blog as a beginners guide to using Faker!

To start, add the faker gem to your project by running "gem install faker" in your project terminal.

Be sure to check that your Gemfile has a line for the faker gem (i.e. gem "faker"). If it doesn't, be sure to add it.

Add "require 'faker'" to the top of your seeds.rb file:

From here, you can use the handy dandy faker documentation to guide you through creating your data.

Here's how I set up data using Faker for a table called "Chefs":

In my Chefs table, I have 3 fields: first_name, last_name, and current_restaurant.

To get a Faker generated first_name, I checked the documentation, found the "Name" category, and saw there was an option to generate a first name: Faker::Name.first_name. You can do pretty much the same thing to generate a last name by using: Faker:: Name.last_name.

Finally, for current_restaurant I searched the documentation and found there is a Faker category for Restaurant! I go ahead and use Faker::Restaurant.name for the current_restaurant field:

From here, you can seed your data like you normally would (rake db:seed). Once your data is done seeding, you'll see randomly generated first names, last names, and current restaurants in your database:

Pretty nifty!

PUT v PATCH

nadia4206 — Thu, 19 Jan 2023 20:23:03 +0000

Did you know that according to the Internet Assigned Numbers Authority, there are 39 different HTTP methods?? 🤯 As a newcomer to coding, I've only been working with a handful of the more common methods like GET, POST, PATCH, and DELETE.

Recently, I learned about the PUT method. Similar to PATCH, PUT updates data, but there are some important differences between the two.

PUT is used to update an entity's data completely. PUT overwrites the entire entity if it already exists, and creates a new resource if it doesn't. What this means is that when working with PUT, you will need to send details for the entire resource, or you will replace the resource only with what you've sent in your PUT request.

PATCH applies a partial update to the resource, meaning you only need to send the data that you want to update. After sending the PATCH request, that specific piece of information will update, without replacing the entire entity.

What does this look like IRL?

Let's say we have a business that offers customizable meal plans. Below is the data we use to update specific meal plans:

{
     "protein": "Flank Steak",
     "vegetable": "Asparagus",
     "starch": "Brown Rice",
     "dessert": "Chocolate Chip Cookie"
    }

I need to update the starch on this meal from Brown Rice to Sweet Potatoes. If I use a PUT request and only send "starch": "Sweet Potatoes", without the other elements, this is what I'll get in return:

{
  "starch": "Sweet Potatoes"
}

If I use a PATCH request only sending "starch": "Sweet Potatoes", the response would return:

 {
     "protein": "Flank Steak",
     "vegetable": "Asparagus",
     "starch": "Sweet Potatoes",
     "dessert": "Chocolate Chip Cookie"
    }

Using PATCH, we could also add another item to the meal, like a beverage, by sending only "beverage": "Orange Cranberry Spritzer". This will add a "beverage" element to the object instead of replacing the entire entity.

 {
     "protein": "Flank Steak",
     "vegetable": "Asparagus",
     "starch": "Sweet Potatoes",
     "dessert": "Chocolate Chip Cookie",
     "beverage": "Orange Cranberry Spritzer"
    }

Happy Coding 💻

Cited Source: https://rapidapi.com/blog/put-vs-patch/

What is the difference between .textContent, .innerText, and .innerHTML?

nadia4206 — Thu, 22 Dec 2022 20:53:45 +0000

Hi! My name is Nadia and I'm currently a student enrolled in the Software Engineering program at Flatiron School.

I just started a few weeks ago and it's been a whirlwind! So much information to digest!

One thing I've noticed is that there are so many different ways to accomplish one goal.

For example, to "set" or "retrieve" the text content of an element, you can use either .textContent, .innerText, or .innerHTML.

Builtin.com has a great article that breaks down the differences:

".innerHTML allows you to see exactly what is in the HTML markup contained within a string."

What this means is that when you call .innerHTML it will return the string and any HTML markup contained within the string.

".innerText approximates the 'rendered' text content of a node and is aware of styling and CSS."
".textContent retrieves and sets the content of the tag as plain text."

At first glance, it seems like .innerText and .textContent are exactly the same. The author of this article goes on to explain that the difference is that .innerText is aware of the rendered appearance while .textContent is not.

What you'll want to use depends on what you want to be able to see!

Referenced Article: https://builtin.com/software-engineering-perspectives/innerhtml-vs-innertext