DEV Community: Kat

Authentication and Security

Kat — Wed, 25 Oct 2023 16:44:29 +0000

Some of the methods we employ to address security issues are:
-before_action: We place this in the controller and name a function that we will write below in the private section that will be run before executing the specified routes. So for instance, before_action :is_authorized_user, only: [:destroy, :create] will run the function is_authorized_user before the create and destroy routes. We place them in the private section to follow the OOP principle of encapsulation and to increase security. This function outlines the logic determining if the current user is authorized to perform the create or destroy methods.
-skip_before_action
-redirect_to
-redirect_back will send the user to the route from which they came, and we can add fallback_location to specify where we want them to be sent in the case that your application can't tell what the previous page was. You can also add a notice.
-current_user
-if/else conditional statements
-only: and except: to limit the routes that are generated in resources (e.g. there's no point in having a delete route for something you don't want to be deletable).

Industrial Grade Codebase: Associations and Validations

Kat — Tue, 24 Oct 2023 20:39:26 +0000

Some additional notes about ways you can modify your tables in your ActiveRecord migrations:

-You can use index: false to shut off indexing. This is useful because each index you add to your table increases how much storage space it takes up. This is especially important if the size of your table is large. Additionally, indexes slow down Create, Update, and Delete operations because the index needs to be updated along with the rest of that data.

-null: false makes it so that this column cannot be empty.

-You have to use a class_name: "Example" in your association in the case that you are deviating from convention. Conversely, you use `foreign_key: "example_id" when the foreign key deviates from convention. Class_name specifies the model you are connecting to with the association, whereas foreign_key specifies the column in the table that connects to the model.

Association Accessors

belongs_to

belongs_to is a direct association accessor. It adds an automatic validation to foreign key columns making a foreign key required unless you override this by adding optional: true. If you remove null: false from any foreign key column in the migration file, you must add optional: true to the corresponding belongs_to.

counter_cache

counter_cache can be added to any belongs_to to keep track of the number of children objects.

Industrial-Grade Codebase: Setting up Data Tables with Devise, Scaffolds, Models

Kat — Tue, 24 Oct 2023 16:38:02 +0000

We are writing industrial-grade code to learn about building up a project from scratch in Ruby on Rails. This blog post will serve as a reference for future projects and attempt to compile and understand what we have learned so far.

For the users table, we're using Devise, one of the most popular authentication GEMS (?) in Rails.

Gem groups allows us to specify gems we want to use in development, production, or all of the time. By compartmentalizing gems like this, it saves memory to not load all the gems all of the time.

We first add gem "Devise" and then bundle install and rails generate devise:install to complete the installation process for Devise. We then have to follow the steps Devise requires in order to use it. The first is defining a root route in the controller.

Once this is taken care of, we generate the users table using rails g devise user username private:boolean likes_count:integer comments_count:integer. Keep in mind string is the default datatype so we can leave that off as is the case with defining username above.

We also then change username and email to citext in our migration. This stands for case-insensitive text and means the column will not be case sensitive thus ensuring you can't have the same username as someone else but with different capitalization, for instance. Don't forget to add the line enable_extension("citext") at the top of your migration to use this. This datatype is a feature of PostgreSQL.

Some things devise does:
-It has steps for handling a forgotten password built in
-It has a bunch of pregenerated columns you can add in to track different user data or activity
-It adds the line add_index :users, :email, unique: true. This speeds up lookups. Otherwise you would have to scan through the entire database to find what you're looking for. Devise does it automatically for email and a good idea to add index for usernames as well since you look users up by username frequently. Adding unique: true adds a database-level check for enforcing uniqueness. On rare cases regular validations may fail so the uniqueness enforcement will be stronger with the added fortification of a database-level check. Also, primary keys are indexed automatically so this isn't necessary for those columns.

For things with a count set a default value, such as likes_count and comment_count. These should generally be initialized to zero. If you don't set a default value, Devise's default is a nil value which can cause issues.

Once the migration is all set up run rake db:migrate and your users table is good to go. (If you have issues run rake db:drop then rake db:create to set up your database.)

Setting up the rest of your data tables

When you're setting up the rest of the tables figure out if it's better to generate a scaffold or a model for each. In general, if your users need to be able to commit CRUD functions in your app, use scaffold. If the model will only be used by other models in the backend, use model.

Delete the null: false option in a column if you want it to have the option of being blank.

Don't forget to update all your associations if you want to use more descriptive foreign key column names than convention.

You will have to use to_table to clarify the table name the foreign key points to when deviating from convention as well. That looks like this:

t.references :owner, null: false, foreign_key: { to_table: :users }

Helper Methods in Ruby

Kat — Fri, 13 Oct 2023 20:45:48 +0000

With the introduction of scaffolding and helper methods, there's a lot of new information to keep track of and a lot of the information that I learned previously will no longer be used regularly. I'm writing this blog post to organize some of the new material and for quick reference for later use.

This post is a work in progress and I will be gradually adding to it over the next few days as I revisit the last few lessons.

Setting up your project: Scaffolding

When you open up a new, blank Rails project, the first step is to set up your MVC. Rails has an easy built-in generator that doesn't require a gem in order to run: scaffold.

To use the scaffold generator, type the following into a bash prompt:

rails generate scaffold <table_name_singular> <column_name>:<data_type> <column_name>:<data_type> <column_name>:<data_type>

Run this and then run rake db:migrate.

What's included with this?

the model.rb for the database table
RESTful starter routes (CRUD) using conventional naming patterns
corresponding templates

Once these are set up, they must be edited for your own needs! It's just starter code.

New Syntax

As we move into this new way of doing things, we are using updated and more professional/concise syntax in our projects.

What does this look like? We'll use the database table name "movies" like we did in lecture.

In routes.rb:

get "/movies", controller: "movies", action: "create"

becomes:

post "/movies" => "movies#create"

Additionally, the root route has its own syntax:

root "movies#index

Further, we will assign method names to each route in the routes.rb file and refer to the routes by their method names in any other file in the project instead of by the url. This helps a lot if you ever have to change the name of the route - rather than going through your whole project and finding any reference to the route, you can just change the method name in routes.rb.

post "/movies" => "movies#create", as: :movies

The convention for each route is as follows:
Create:
/movies/new = :new_movie
post /movies = :movies

Read:
/movies - you don't have to put anything.
/movies/:id = :movie

Update:
patch - you don't have to put anything.
/movies/:id/edit = :edit_movie

Delete:
You don't have to put anything for this route.

I don't really get why you don't have to put the helper method for all of them so I have to figure that out.

link_to

The link_to helper method is generates links for you as opposed to having to write them yourself. It enables you to use the route method names you previously set up and can actually find these by itself if you're using conventional naming patterns.

form_with

The form_with helper method can replace the <form> HTML tag and has a few benefits including automatically generating the authenticity token we need to prevent malicious attacks (cross-site request forgery). Forms with a path other than get cannot be submitted without this token. It takes a hash as an argument that contains the path. You can also include the method if it's something like patch so you don't have to include this as a hidden input anymore. We are also including data: {turbo: false} because turbo is automatically on in the version of Ruby we're using.

form_with is a code block so you have to then end the block at the end of the form.

We use a label tag like so:

<%= label_tag :description, "Description" %>

The first argument to the label_tag is the for= attribute from our old label tags, which connects the label to the input field via the input field's ID. The second one is the content if that's something different - what the label actually says.

There are different helper methods for each type of input such as a text area, checkbox, etc. For these, the first argument is the name & id (if they're the same) and the second populates the value attribute. You can also add a hash for additional attributes like rows in a text area or the id if it's not the same as the name.

Databases with Rails: Review

Kat — Thu, 28 Sep 2023 17:15:30 +0000

Here is a recap of some of the main points regarding databases and using databases with Ruby on Rails for reference compiled from the information from class.

Relational databases are databases structured around the data type "relation", which refers to a set of records modeled off a table. Relational databases use SQL. The apps that we build output SQL commands that create, read, update, or delete rows of data and send them to the database for processing.

To create a database and start working with it:

Launch psql from a bash prompt
In psql, create a database using the command CREATE DATABASE <database_name>.
Connect to the database with the command \connect <database_name>.
Create a table with the command

  CREATE TABLE <table_name> (
    ---table columns and datatype---
  );

Configure the Rails application to use the database by editing config/database.yml line 26 (current) to: database: <database_name>.
Create a model called the singular form of the corresponding table name and inherit from ActiveRecord::Base.

To work with your database, use the terminal command rails console or rails c which launches psql and automatically connects to the database specified in config/database.yml.

ActiveRecord
ActiveRecord is a Ruby gem that automates most of the process of connecting to your database and performing CRUD operations.

Cookies

Kat — Tue, 08 Aug 2023 03:49:30 +0000

We use cookies every day but I've never really understood what they do or how they work. The lesson "the cookies hash" was helpful in elucidating the basic concept of what cookies are and what they do.

Essentially, cookies are "a set of key-value pairs" that the server stores in the client. Simple! Then, the data are sent back to the server with a header "Cookie" every time the client makes another HTTP request. Thus, the server can keep track of things like client preferences or the identity of a logged-in user.

The cookies hash can be accessed using the same hash methods as a regular hash. However, the keys and values can only be stored as strings. Thus, any other data type must be encoded as a string and later decoded back into the data type it was originally. The best way to do this is through the use of JSON strings. For this process, we use the methods JSON.parse(string) and JSON.generate(hash).

Views and more

Kat — Mon, 07 Aug 2023 16:42:43 +0000

To incorporate Ruby and HTML together in a page, Sinatra provides a folder called views, where you can put .erb files. These files are primarily HTML but you can add erb tags to inject some Ruby, which your browser will read as the HTML the Ruby code snippets represent. This is a great way to put logic or variables directly into your HTML templates.

If you have code that will be repeated in various templates, this can be placed in the folder layout.erb. The code from the other erb files will appear where you place the <%= yield %> tag.

Putting { :layout => false } in the app.rb file for a specific route will turn off the layout for that particular view, or you can override the layout with a different one using { :layout => :other_layout }.

use :variable in your path to create a dynamic variable. The variable params allows us to get those in the form of a hash.

We also learned about the importance of automated tests. They're super helpful when refactoring code to make sure that the functionality of the original has been maintained, and can test a number of user inputs automatically. While writing the code for these tests takes some time, possibly longer than writing the code that will be tested itself, it is a great time investment as it ensures functional code over time and over changes to the codebase.

Classes

Kat — Mon, 31 Jul 2023 18:02:03 +0000

Classes serve as a blueprint for instances of objects in programming. Today I learned about creating classes in Ruby. A few notes:

-We only use capital letters in Ruby when referring to classes.
-A multi-word class name should be in CamelCase.
-The keyword attr_accessor is used to declare the attributes of a class.
-We can define our own methods within a class using the keyword def.

Here is an example of a class with a class method.

class Cat
  attr_accessor :name
  attr_accessor :age
  attr_accessor :fur_color

  def meow
    return self.name + " says 'Meow!' :3"
  end
end

Another important keyword in classes is self. According to the learn materials, this keyword "refers to the class it is inside of and can be used to refer to all the attributes of that class".

Additionally, this module discusses inheritance, which is one of the four pillars of object-oriented programming, or OOP, the most commonly used modern programming paradigm. Inheritance basically means that you can create subclasses of any class that inherit the attributes and methods of the parent class (but also have their own!).

The syntax to a subclass is:

class SubClass < ParentClass

Ruby Syntax: Each

Kat — Sat, 29 Jul 2023 15:50:13 +0000

Today's module introduced a really interesting array method in Ruby: each. This is an efficient way to loop over elements in an array in Ruby.

"Each" can be used with "do" and a block variable to create an iterative loop rather than using a while loop or for loop and has the benefit of not requiring a value to be incremented in order to move to the next element in the array. Also, it doesn't require us to know the number of elements in the array, as would be the case if we used .times.

This makes our code more concise!

Here is an example of how to print each element in an array using .each:

my_array = ["cat", "dog", "hamster", "frog", "parakeet"]
my_array.each do |animal|
  pp animal
end

TIL...GitHub pages!

Kat — Wed, 26 Jul 2023 19:59:27 +0000

For today's assignment, I used GitHub pages for the second time to deploy a project. It's great to have such a simple way to deploy websites directly through GitHub! I plan to use this method moving forward to deploy projects I have built in order to demonstrate my portfolio to potential employers/collaborators.

TIL...

Kat — Wed, 12 Jul 2023 22:57:07 +0000

First post! Testing 1 2 3...