DEV Community: Robin Vernon

Let’s talk Relations

Robin Vernon — Mon, 11 Apr 2022 20:06:13 +0000

When getting started on a Ruby or Rails app, you may find that you have many tables that correlate. For example, let’s say we are making an app for a football team, this team plays in many games throughout the season but has their own stadium in their city. If we wanted to show the relation in a rails, we would use the macros in the Teams model:

Belongs_to

We can use this macro to state that the team belongs to a specific city. (Notice that city is singular)

Belongs_to :city

Has_many

We use this to show that the Football team participates in many games throughout the season. With this relation, we could call TeamName.Games.All and the console would return all games the team has participated in.

Has_many :games

Has_many. , through:
We can use this macro to show nested relations or relations that happen through an already associated relation.

Has_many :points, through: :games

Now if we seeded our DB to display points for each team(that would be a lot of instances), I would be able to call
TeamName.Points.All and the console would return the points from each game. This is because we now have access to points, through the games class.

Simple enough right? If you found this informative, I’d love to hear your feedback.
Check out my github to see how i use these macros:
https://github.com/robinlashae1

React: Components

Robin Vernon — Mon, 21 Mar 2022 06:02:47 +0000

When first learning React, a key concept you’ll encounter are components. These are essentially building blocks for your app. They help to make your code “dry”, dynamic and are an essential part of what developers like to call SOC, or separation of concern. To truly understand how powerful components are, it’s important to know why we use them.

What is Dry Code?

The term “Dry” code refers to the principle that it is both a bad practice and a waste of time to repeat yourself in coding. The excess amount of code we get when we overwrite can lead to a major decrease in readability and more room for bugs. Instead we prefer to keep out code D.R.Y, and one way we can do that is with react components. With these components, we can create reusable functions that can be referenced and passed down to cut out extra wording. This helps to make our code dynamic, which by definition is “characterized by constant change, activity, or progress”. In development, this just means, “can your code adapt to change?”. With components and props, this is very possible, especially with the help of dry code.

What is SoC?

In Development, this is the principle of separating your program into different sections based on what they accomplish. In theory, it’s possible to have everything in one place, but that would probably be chaotic. The readability of that app would be exhausting and it would be so hard to debug. Instead, we use components to separate our concerns and focus solely on them. This is very important here, because we wouldn’t want to code our filter feature in the same place we’re adding a form/add/delete feature. This lest us organize in a way that is beneficial for us and whoever else will read our code. After we’ve accomplished what we want, we can simply call this component in our parent app to render it correctly. Separation of concerns is such an easy way to avoid confusion and make an app more organized.

What advise do you wish you knew when starting with react? Open to feedback.
check out my github to see some of my react apps:
https://github.com/robinlashae1

A Basic guide to Active Record Commands

Robin Vernon — Mon, 21 Mar 2022 05:55:43 +0000

When transitioning to Ruby’s active record, the commands can be a little long winded and tedious. Here i have provided a cheat sheet to basic AR commands

Classes

When working with Active Record and making classes, often we will have to write methods, below are some of the basic methods you will most likely encounter along.

.column_names
Retrieve a list of all the columns in the table

.create
Create a new entry in the database and saves it

.all
Return all the desired instances of the class from the table

.find
Retrieve an instance from the database by id

.find_by
Find by any attribute(ie. name)

.Attr_accessors
You can get or set attributes of an instance

#save
save changes to the database

.Find_or_create_by
Finds the first instance with the given attributes, or creates a instance with the attributes if one does not exist

Rake
Using rake commands can sometimes get a little confusing, especially with the bundle exec prefix, these are the task you’ll likely encounter most

Create migration
bundle exec rake db:create_migration NAME=

Migrate
bundle exec rake db:migrate

Create Table

create_table :modelName do |t|

      t.string :name

      t.string :genre

      t.integer :age

      t.string :hometown

end

Check status
bundle exec rake db:migrate:status

Rollback
bundle exec rake db:rollback

Running a seed file
bundle exec rake db:seed

or to replant with new data
bundle exec rake db:seed:replant

Looping faker gem

Another amazing tool we can use is the faker gem, once we have created our migrations and tables, we can use this gem in the seed file to fill our tables with dummy data. This is particularly useful when wanting to test methods

50.times do

  # create a movie with random data

  Movie.create(

    title: Faker::Movie.title,

    genre: Faker::Movie.genre,

    ticket_price: rand(0..20) # random number between 0 and 20

  )

end

Though this isnt everything, hopefully this will help you when diving into ORM!! Happy coding!
check out my github to see how i utilize these:
https://github.com/robinlashae1

Instance Vs. Class

Robin Vernon — Wed, 16 Mar 2022 03:59:56 +0000

On introduction, the idea of instances and classes can seem overwhelming. However, they are actually quite simple concepts to understand over time. Let’s take a step back, and look at them in another light.

What is a Class?
A class is in practice, a blueprint while an instance is a single occurrence of a class. Let’s think about it like this, when creating a table for a car class, I might say it has a make, model, color, and a year. These attributes would be defined in our table and permitted in our create method. These blueprints aren't the actual car, instead they lay out step by step what every car should consist of and give us other helpful information (Class Methods) to be used in creation.

What is an Instance?
An instance is the product of a class. For example, an instance of our Cars class could be a black 2019 Dodge Charger. Another instance could be a 1993 red Chevy. These are all single occurrences of the cars class, all following the specific blueprint we created. These instances are all unique in value, but they still share the same attributes. If we were to strip the instances down to their very basic mold, they have a make, model, color and year. This is how the blueprint is used.
How to create an instance:
Using our previous Car class and assuming string types for all except year, we could use .create
Car.create(make: "Dodge",model: "Charger",color: "Matte Black",year: 2015)
or we could assign an instance to a variable:
assuming we have setter and getter methods in our class file
attr_reader :make, :model, :color, :year
we could go the following in our rails console
my_new_car = Car.new my_new_car.make= "Dodge" my_new_car.model= "Charger" my_new_car.color= "Blue" my_new_car.year= 2015

Which way do you like more? Open to feedback.
check out my github to see which method I like most:
https://github.com/robinlashae1

Renaming a Rails app

Robin Vernon — Sun, 19 Dec 2021 20:38:14 +0000

Have you ever began a project without having a solid name picked out? I'm sure all of us have at least once. This is completely ok, we shouldn't just let inspiration fade because we can't think of a application name. Once an appropriate name sticks with you, it's time to rename your application. When trying you do this manually, you'll find that this really isn't an easy thing to do. However, thanks to Morshed Alam's "rename" gem , all the dirty work is done for us. This gem goes through your application and relabels where appropriate.
HOW TO:

Add this to your gemfile

gem "rename"

Rename your app

rails g rename:app_to updated_name

Optional Rename your Database (in order to do this, you must be logged into Postgresql)

ALTER DATABASE db_name RENAME TO new_db_name

And Voila, you're done. Please note that the app you're currently in will no longer be useable. Navigate to the directory this file is in and your newly named app should be there!

Is there anything that you would do differently? Did this work for you? Open to feedback Devs!