Forem: grant-ours

Active Record Validations

grant-ours — Wed, 26 Oct 2022 21:55:42 +0000

Overview

What is a Validation?

Here's an example.

class User < ApplicationRecord
  validates :name, presence: true
end

irb> User.create(name: "John Doe").valid?
=> true
irb> User.create(name: nil).valid?
=> false

The validation lets us know that our User is not valid without a name attribute. The second User will not be persisted to the database because it did not pass validation.

Why Use Validation?

Validations are used to make sure that only valid data is saved into your database. For example, it may be important in your application to ensure that every user provides a valid username and password. Model-level validations are the best way to ensure that only valid data is saved into your database. Validations cannot be bypassed by end users and are convenient to test and maintain. Rails provides built-in helpers for common needs, and allows you to create your own validation methods as well but I wont be covering all that here.

There are several other ways to validate data before it is saved into your database, including native database constraints, client-side validations and controller-level validations.

When Does Validation Happen?

There are two kinds of Active Record objects: those that correspond to a row inside your database and those that do not. When you create a new object, for example using the new method, that object does not belong to the database yet. Once you call save on that object it will be saved into the appropriate database table. Active Record uses the new_record? instance method to determine whether an object is already in the database or not. In this example we have an Active Record class with no validations:

irb> u = User.new(username: "Johnny")
=> #<User id: nil, username: "Johnny", created_at: nil, updated_at: nil>

irb> u.new_record?
=> true

irb> u.save
=> true

irb> u.new_record?
=> false

Creating and saving a new record will send an SQL INSERT operation to the database. Updating an existing record will send an SQL UPDATE operation instead. Validations are typically run before these commands are sent to the database. If any validations fail, the object will be marked as invalid and Active Record will not perform the INSERT or UPDATE operation. This prevents us from storing an invalid object in the database. You can choose to have specific validations run when an object is created, saved, or updated.

The following methods trigger validations, and will save the object to the database only if the object is valid:

create
create!
save
save!
update
update!

The bang operator ("!") at the end of the method raises an exception if the record is invalid. The non-bang versions don't: save and update return false, and create returns the object.

The following methods skip validations, and will save the object to the database whether it's valid or not. They should be used carefully.

decrement!
decrement_counter
increment!
increment_counter
insert
insert!
insert_all
insert_all!
toggle!
touch
touch_all
update_all
update_attribute
update_column
update_columns
update_counters
upsert
upsert_all

valid? and invalid?

Before saving an Active Record object, Rails runs your validations. If these validations produce any errors, Rails does not save the object.

You can also run these validations on your own. valid? triggers your validations and returns true if no errors were found in the object, and false otherwise. invalid? is the inverse of valid?. It triggers your validations, returning true if any errors were found in the object, and false otherwise.

There are many helper methods and different ways to deal with and display error messages but I wont delve into those here. Feel free to check them out here https://guides.rubyonrails.org/active_record_validations.html

Many-to-Many Relationships

grant-ours — Mon, 10 Oct 2022 21:34:49 +0000

Many-to-many relationships

are one of the more common relationships in Rails. When two models have a has_many association to each other, we say they are in a many-to-many relationship.

Here's a many-to-many relationship for example, a doctor can have many patients, and a patient can see many different doctors.

One way to set up a many-to-many relationship with another model is to use the has_many :through association. In order to do that, we need to create a new join model. For this example we will use Doctor, Patient and Appointment.

class Doctor < ApplicationRecord
  has_many :appointments
  has_many :patients, through: :appointments
end

class Appointment < ApplicationRecord
  belongs_to :doctor
  belongs_to :patient
end

class Patient < ApplicationRecord
  has_many :appointments
  has_many :doctors, through: :appointments
end

But how can we control the associated object when its owner is destroyed?

You can set a dependent to handle these conditions.

For example if I wanted to delete a Doctor I'd need to make sure all of their appointments were taken care of. We'd do that like this.

class Doctor < ApplicationRecord
  has_many :appointments, dependent: :destroy
  has_many :patients, through: :appointments
end

For more on active record associations check out: https://guides.rubyonrails.org/association_basics.html

Ruby Methods

grant-ours — Mon, 19 Sep 2022 07:08:08 +0000

What Are Methods

Ruby methods are like functions in other programming languages. Ruby methods are used to group repeatable code into a single reusable methods.

Method names should not be capitalized. If you begin a method name with an uppercase letter, Ruby might think that it is a constant. The convention is to use underscores to separate words if your method name has more than one word.

How to Define a Method

Methods should be defined before calling them:

A methods definition starts with the 'def' keyword followed by the methods name.
Method parameters are specified between parentheses after the methods name.
The methods definition ends with the 'end' keyword on the last line similar to a closing bracket for a function.

Syntax example:

def method_name(argument)
  puts argument 
end

Naming Methods

Method names may end with a "!"(bang operator), a "?" or "=".

The bang methods(! at the end of method name) are called and executed just like any other method.
Methods that end with a question mark by convention return a boolean. They may not always return just true or false, but usually they return an object which in ruby is a truthy value.
Methods that end with an equals sign indicate an assignment method. For assignment methods the return value is ignored, the arguments are returned instead.

Arguments

A Ruby method can accept arguments.

The list of arguments follows the method name.
The parentheses around the arguments are optional.
Multiple arguments are separated by a comma.
The arguments are positional.

Syntax example:

def multiply_values(num1, num2)
  return num1 * num2 
end

Default Values

You can set default values of arguments. The default value does not need to be listed first, but arguments with defaults must be listed together.

Syntax example:

def multiply_values(num1, num2 = 6)
  return num1 * num2 
end

useState Hook

grant-ours — Fri, 26 Aug 2022 20:05:44 +0000

What Are Hooks?

Hooks are new! It was a feature introduced in React 16.8. It allows you to use state and other React features without writing a class. Hooks are functions which "hook into" React features. It does not work inside classes.

When Should I useState vs Props?

Choosing whether to use state vs props comes down to "who owns this data?". If data is managed by one component, but another component needs access to that data, you'd pass the data from the one component to the other component via props.

If a component manages the data itself, it should use state to manage it.

Example

I'm going to show how to use state in a simple cookie clicker app.

Declaring State

import React, { useState } from 'react';

function Example() {
  // Declare a new state variable, which we'll call "cookies"
  const [cookies, setCookies] = useState(0);

What Does Declaring State Do?

It declares a “state variable” and a callback function. Our variable is called cookies but you could call it anything. The setCookies function will set the new value of cookies. This is a way to “preserve” some values between the function calls. Normally, variables “disappear” when the function exits but state variables are preserved by React. We pass 0 into useState to set our "initial state". Meaning our cookie clicker count will start at 0.

How to Display Your Current State

If we want to display the current amount of cookies that we have we can use cookies directly:

<p>You have {cookies} cookies!</p>

How to Update State

  <button onClick={() => setCookies(cookies + 1)}>
    Click for Cookie!
  </button>

Thats it!

 1:  import React, { useState } from 'react';
 2:
 3:  function Example() {
 4:    const [cookies, setCookies] = useState(0);
 5:
 6:    return (
 7:      <div>
 8:        <p>You have {cookies} cookies!</p>
 9:        <button onClick={() => setCookies(cookies + 1)}>
10:         Click for Cookie!
11:        </button>
12:      </div>
13:    );
14:  }

We import the useState hook from react. This is how we keep track of state in our function.
We declare state by calling our useState hook, assign our state variable and callback function a name, and initialize state by passing a 0 indicating that we start with no cookies.
Then, when a user clicks the button, we call setCookies with a new value. React will then re-render the Example component, passing the new cookies value to it.

Taking a Look at Conditional Statements

grant-ours — Wed, 03 Aug 2022 23:56:00 +0000

`if`, `else`, and `else if`

When you're writing code and you want to perform different actions based on different decisions. This is where if statements come in handy!

`if` Statements

Use an if statement to run a specified block of code if a certain condition is true.

Example Structure of an if statement

if (condition) {
   // insert code here to be executed if the condition is true
}

`else` Statements

Use an else statement to run a specified block of code if the condition is false.

Example Structure of an else statement

if (condition) {
   // insert code here to be executed if the condition is true
}else{
   // insert code here to be executed if the condition is false
}

`else if` Statements

Use an else if statement to add a second condition if the first condition is false.

Example Structure of an else statement

if (1st condition) {
   // insert code here to be executed if the condition is true
} else if (2nd condition) {
   // insert code here to be executed if the first condition is false and the second condition is true
} else {
   // insert code here to be executed if the first condition is false and the second condition is false
}

Pro Tip: Use console.log through out the process to figure out what is happening in your program and where!

Forem: grant-ours

Active Record Validations

Overview

valid? and invalid?

Many-to-Many Relationships

Many-to-many relationships

Ruby Methods

What Are Methods

How to Define a Method

Naming Methods

Arguments

Default Values

useState Hook

Example

Thats it!

Taking a Look at Conditional Statements

if, else, and else if

if Statements

else Statements

else if Statements

`if`, `else`, and `else if`

`if` Statements

`else` Statements

`else if` Statements