Forem: losetom

Validations in Ruby

losetom — Mon, 19 Dec 2022 16:32:53 +0000

What is a "validation"?

In terms of strict English, a validation is a method that serves as a way of confirming something is what it is before anything else happens.

"Does this dress look good on me? I want to validate that it's not tacky and okay to wear to the party."

Definitely not the most normal human interaction but you get it.

Validations in code are essentially the same thing! They consist of code that protects the database from receiving invalid data that may harm the database or other aspects of the application.

We implement validations to assure ourselves that we are receiving the correct information every time.

One method of validations can be handled through ActiveRecord, which we will discuss in a later blog. For now, this is how it will look.

Basic Usage

 class Person < ActiveRecord::Base
   validates :name, presence: true
 end

#validates is doing exactly what it looks like it's doing. It is accepting the name of the attribute that we want to validate (:name) and accepting a hash of options that includes the details of the validation. { presence: true } is a very basic validation that checks that there is at least something present for the :name attribute.

Well, writing validations is nice, but, how do we even know if something is validated or not?

We can check manually with #valid?


class Person < Active Record::Base
  validates :name, presence: true
end

person = Person.new
person.valid? #=> false

Above, we created a new person and set it equal to person. We then called #valid? on our new person and returned a value of false. Why is it false? Let's check with errors.messages!

person = Person.new
person.errors.messages #=> name: can't be blank

We did not create a new person with a name, therefore, failing the validation of { presence: true } in reference to the name attribute.

To give our users more information on the validation error, we can also render our validation errors as JSON in our controllers, which will be discussed in another blog post.

def create
  person = Person.create(person_params)
  if person.valid?
    render json: person, status: :created
  else
    render json: { error: person.errors }, status: :unprocessable_entity
  end
end

render json: { error: person.errors } : This line of code is doing exactly what we did before when we called person.errors.messages but displaying it as JSON for the user to see on their end, the frontend.

Other Built-In Validators

Length

length is one of the most versatile because most inputs, if not all, will be a certain amount of characters long.

class Person < Active Record::Base
  validates :name, length: { minimum: 2 }
  validates :bio, length: { maximum: 500 }
  validates :password, length: { in: 6..20 }
  validates :registration_number, length: { is: 6 }
end

Uniqueness

uniqueness is also very common as it is used to ensure that the same username or email cannot be used for more than user account.

class Account < Active Record::Base
  validates :email, uniqueness: true
end

Custom Messages

class Alien < Active Record::Base
  validates :not_a_human, acceptance: true, message: "Extraterrestrials only!"
end

You can say whatever you want for the errors! Make it yours!

Conclusion

We covered the importance of validations and why they are necessary for any application worth using. If you want a secure database, validations must be implemented. If you want to feel safe as a consumer, make sure the applications that use have validations implemented. We went over common validation methods and use-cases.

Resources

https://guides.rubyonrails.org/active_record_validations.html

https://web-crunch.com/posts/understanding-ruby-on-rails-activerecord-validations

Object-Oriented Design

losetom — Mon, 24 Oct 2022 15:26:32 +0000

Designing in any regards is not a straight line. As we try to develop something whether it be a computer program, a painting, or even a plate of food, we try to adhere to certain principles and patterns to guide us in creating the best product possible.

Object orientation follows 3 main principles:

1) Separation of Concerns
2) DRY (Don't Repeat Yourself)
3) Line Limits.

Single Responsibility and Separation of Concerns

In Ruby, we have this concept of single responsibility, which is exactly what it sounds like; classes will have one job. This also means their services are aligned to facilitate that one job. This concept ties into separation of concerns. Each responsibility of a computer program needs to be separated and handle a different objective.

class MyStore

  def sign_in(user)
    @user = user
  end

  def current_user
    @user
  end

  def item(item)
    @item = item
  end

  def item_price=(price)
    @item_price = price
  end

  def shopping_cart
    @shopping_cart = []
  end

  def add_item_to_cart(item)
    @shopping_cart << item
  end

  ...

end

Each concern here is defined in its own class and handles a single responsibility. sign_in will handle signing in to the program, current_user recognizes the user signing in, item defines items in the program, and so on. If something were to go awry in our application and needs correcting, we don't have to disrupt other parts of the code that may potentially cause more problems than are already occurring.

Don't Repeat Yourself

def checkout(discount=0)
  total = 0
  shopping_cart.each do |item|
    total += item.price
  end

  if discount == 10
    total = total - total * 10 / 100.00
  elsif discount == 20
    total = total - total * 20 / 100.00
  elsif discount == 50
    total = total - total * 50 / 100.00
  end

  total

end

This block of code is messy and repetitive. While it gets the job done, it is prone to breaking and any maintenance needed could cause more issues. If we were to re-factor, it would look like this:

if coupon
      total = total - total * coupon / 100.00
    end

We have now achieved the same function but with less code. This allows for the program to run smoother and if any maintenance is necessary, it is flexible and less prone to causing greater issues.

Line Limits

The final principle of object-oriented design would be line limits. Methods should not exceed 5 lines of code and classes should not exceed 100. These limits are not absolutely strict and are open to exceptions. They simply serve as a guide to writing clean and effective code. Programming is all about efficiency and effectiveness. If we have a block of code that's 20 lines long but we can refactor to achieve the same function in 5 lines, we should. If we think in terms of the shortest, most effective code possible, we can generate more efficient and less costly programs that are also easier to read, maintain, and update.

Conclusion

These three main concepts of object oriented design are meant as guides, not strictures. While they are not absolutely necessary, they are critical in developing real-world applications that are cost effective, easy to use, and easy to maintain. They also keep you sane which is incredibly important in the world of software engineering! There are many moving parts in this field so if there is someway to make our experience faster and easier, developers will do better and feel better in the long run.

References

https://www.poodr.com/
https://www.rubyguides.com/ruby-tutorial/object-oriented-programming/

useState() in React

losetom — Tue, 20 Sep 2022 12:16:51 +0000

React has hooks which allow programmers to access features of React without having to use classes. One of these hooks is called useState().

The first step to applying useState is by importing the hook to the file of your choosing, as seen in the example below.

import { useState } from "react";

The next step is to initialize the useState hook that was just imported by calling it in our function component. useState will accept an initial state and then return two values: the current state and a function that updates the state.

import { useState } from "react";

function Counter() {
const [count, setCount] = useState(0);
}

The first value here is count, which is our current state. The second value is setCount, a function which will update state based on the user input.

Finally, we set the initial state to a number value with useState(0). The parentheses can hold a string, boolean, arrays, objects, or any combination of these values.

To make this useState functional, we can add a click event and a button to make this work.

import { useState } from "react";

function Counter() {
const [count, setCount] = useState(0);
}

return (

setCount(count + 1)}> Click!

);
}

This code creates a button that holds an initial state of 0 and will count upward from that value of 0 every time the button is clicked.

Resources

https://reactjs.org/docs/hooks-state.html

https://www.w3schools.com/react/react_usestate.asp

forEach() in JavaScript

losetom — Tue, 16 Aug 2022 18:18:00 +0000

The forEach() method in JavaScript does not have a built-in return value like methods such as map() and filter() do but its generic properties make it very flexible as whatever callback function is passed in can have whatever functionality we want it to have.

The forEach() method will execute a given function for each array item in an ascending index order.

The callback function for forEach() will be invoked with three given arguments:

The value of the element
The index of the element
The array object being traversed

You can print values of an array to the console for visualization of the functionality.

e.g.
const numbers = [1, 2, 3, 4, 5]
numbers.forEach(itemLog);

function itemLog(item, index, array) {
console.log(item);
}

1
2
3
4
5

This example shows the numbers in the array are simply being printed to the console.

forEach() also allows the user to display the position, or index, of each value in the array.

e.g.

const numbers = [1, 2, 3, 4, 5]
numbers.forEach(itemLog);

function itemLog(item, index, array) {
console.log('a[' + index + '] = ' + item);
}

a[0] = 1
a[1] = 2
a[2] = 3
a[3] = 4
a[4] = 5

This example displays the index position of each value in the array.

const numbers = [1, 2, 3, 4, 5]
numbers.forEach(itemLog);

function itemLog(item, index, array) {
console.log(array)

[1, 2, 3, 4, 5]
[1, 2, 3, 4, 5]
[1, 2, 3, 4, 5]
[1, 2, 3, 4, 5]
[1, 2, 3, 4, 5]

This example displays the array being printed as called.

If given an array of numbers, forEach() can also be used to provide the sum of those values in the array.

For this example, I will use an arrow function to show how the code written above can be condensed.

const numbers = [1, 2, 3, 4, 5]

let sum = 0
// To return the sum of an array, it must first start at 0 so, let sum = 0

numbers.forEach(item => {
sum += item
)}

console.log(sum);

The value of 15 will be printed to the console as it is the sum of the values provided in the array.

forEach() is not the most useful of the JavaScript array methods but it offers a good alternative to writing lengthy for loops and provides a good visualization of the nature and behavior of arrays when they are being targeted with different methods.

Resources:

https://www.youtube.com/watch?v=SXb5LN_opbA&ab_channel=FlorinPop

https://www.w3schools.com/jsref/jsref_forEach.asp

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/forEach