Forem: Felice Forby

Database Video Notes

Felice Forby — Fri, 25 Oct 2024 12:11:14 +0000

SQL Basics (M04 L01)

The Basic SELECT (M04 L02)

DATES, Order By, NULLS (M04 L03)

SQL statements can be divided into 2 categories:

Data definition language (DDL) statements: used for creating tables, relationships, and other structures.
Data manipulation language (DML) statements: used for queries, inserting, and data modification.
SQL is not procedural: it does not execute one statement at a time in a sequence, rather, it executes the entire query all at once.
All inputs to a SQL query are tables and the output from a query is another table called the Answer Set.
Some queries can produce interim/temporary answer sets. Note that these aren't seen but they consume resources

Optimizer calculates the optimal execution plan for a query.

Combine conditions with AND and OR, use parentheses when needed

Group Functions (M04 L04)

https://www.youtube.com/watch?v=v-ZUPvNAwuk
https://drive.google.com/file/d/18QiIO69xnHsYOgkXutHZFxQtIeRBQTlf/view?usp=drive_link
When you combine a GROUP function w/ a WHERE clause, the WHERE clause reduces the number of rows in the interim answer set before the GROUP function does its calculation.
A GROUP function w/o a GROUP BY returns only one row in the answer set
A GROUP function w/ a GROUP BY returns multiple summary rows in the answer set showing a subtotal across all rows from the interim answer set summed by the column on which we GROUP BY
RULE: When using a GROUP BY, every column in the SELECT statement must either be:
- a column to which you apply the group function (note this column does not have to be in the group by)
- a column that you are grouping by
- (Strict mode will fail with errors)

select @@sql_mode;
-- strict mode
SET sql_mode = 'ONLY_FULL_GROUP_BY';
-- relaxed mode
SET sql_mode = '';

HAVING

Like a WHERE clause against the interim answer set when you use a GROUP BY
Returns a subset of rows from the interim answer set

5 group functions:

SUM (only numeric)
AVG (only numeric)
COUNT (any column, or * to count rows)
MIN (work with any type of column)
MAX (work with any type of column)

SQL Subqueries (M05 L01)

Query within a query:

Subquery in WHERE: answer set to the inner query is used as a predicate in a WHERE clause in the outer query
- Can also be used to get list for IN clause
Subquery in SELECT: answer set to the inner query is used as column in a SELECT
- Need to name the subquery column
Subquery in FROM: answer set to the inner query is used as "virtual" table in a FROM clause
Need to name the subquery alias name
Subquery must always be enclosed in parentheses!
Can select from a different table

Co-Related SubQuery

Inner query references a value from outer query
Inner query is re-executed w/ each row returned by outer query
Rare, can be very slow performance!

SQL JOINs (M05 L02)

Used for getting data from multiple tables.

Joining two tables requires that they have a common key (usually FK relationship) that appears in both tables. Keys must be same length and data type, but don't need to have the same name.
Joins consume extra resources
Need to prefix identical column names with the table name

SELECT LastName, FirstName, COUNT(OrderID) AS 'Orders'
FROM Employees, Orders
WHERE Employees.EmployeeId = Orders.EmployeeID
GROUP BY LastName, FirstName
ORDER BY COUNT(OrderID) DESC;

The Cartesian Product (M05 L03)

https://www.youtube.com/watch?v=vXOLWJuG2-0
https://drive.google.com/file/d/14pDedK8XgdVNQq6XeH2dG70oteuVjBm3/view?usp=drive_link
Product = one table multiplied by another table
JOIN often creates a product, then selects rows from the product where keys match (most rows are meaning less)
NEED TO AVOID by fully qualifying the JOIN with a WHERE, e.g. matching all the joined IDs in the where. Can happen if a join clause is missing.
For every X tables you are joining, you must have X - 1 JOIN conditions, If not you may generate a meaningless answer set due to creation of a Cartesian product.

More SQL JOINs (M05 L04)

Using the JOIN keyword as an alternate. The below are equivalent:

SELECT LastName, FirstName, COUNT(OrderID) AS 'Orders'
FROM Employees, Orders
WHERE Employees.EmployeeID = Orders.EmployeeID
GROUP BY LastName, FirstName
ORDER BY COUNT(OrderID) DESC;

SELECT LastName, FirstName, COUNT(OrderID) AS 'Orders'
FROM Employees 
INNER JOIN Orders ON Employees.EmployeeID = Orders.EmployeeID
GROUP BY LastName, FirstName
ORDER BY COUNT(OrderID) DESC;

Every pair of tables being joined must have a common key
Every pair of common keys must have a condition stated in a WHERE clause or in the ON clause of the JOIN (if not could get Cartesian product)
Note that joins are expensive! If joining multiple tables, it could be better to do multiple queries and have the output of a join query saved as a temporary table, then bring that temp table into the next join query.

Joining multiple tables

SELECT LastName, FirstName, SUM(UnitPrice * Quantity) AS 'OrderValue'
FROM Employees 
JOIN Orders ON Employees.EmployeeID = Orders.EmployeeID
JOIN OrderDetails ON Orders.OrderID = OrderDetails.OrderID
GROUP BY LastName, FirstName;

-- With WHERE
WHERE Employees.EmployeeID = Orders.EmployeeID
  AND Orders.OrderID = OrderDetails.OrderID

By default, a JOIN is an INNER JOIN
Explicit JOIN: when the JOIN keyword is used
Implicit JOIN: when WHERE is used to define the join

SQL Outer Join (M05 L05)

https://www.youtube.com/watch?v=fLaLIZpdsM8
https://drive.google.com/file/d/1l_sTJIBjoRPKa3z4jc9mSbkFN_-D6YgK/view?usp=drive_link
INNER JOIN: the intersection between 2 tables. Returns all the rows that match between the tables
RIGHT OUTER JOIN: All of the rows where the keys match between both tables PLUS all the rows from the "right" table. All the rows of the right table and matching rows from left table
LEFT OUTER JOIN: All of the rows where the keys match between both tables PLUS all the rows from the "left" table. All the rows of the left table and matching rows from right table

Outer JOIN is useful for analyzing data

Left outer join

Left table is the one mentioned first in the SELECT FROM. Below, Employees is left and Department is right. All rows from Employees (left) and only matching rows from Department (right) are shown.

SELECT *
FROM Employees E
LEFT OUTER JOIN Department D
ON E.DepartmentID = D.DepartmentID

Right outer join

All rows from Department (right) and only matching rows from Employees (left)

SELECT *
FROM Employees E
RIGHT OUTER JOIN Department D
ON E.DepartmentID = D.DepartmentID

Note on UNION

Assemble multiple queries connected by a UNION
Combine multiple answer sets
Each answer set must have same # of columns
Each column in all answer sets must have same domain (same set of data values)

Execution Plans

With any join, the DB engine optimizer must calculate the most efficient query execution plan. There are 3 basic methods in MySQL:

Nested Loop Join: when one join input table has a small number of rows and the other input table is large and indexed on the join key. Most efficient.
Merge Join: when tables being joined are both sorted on the join key. Next efficient.
Hash Join: when large, unsorted, non-indexed inputs are joined with an inner join with an "=" condition. Least efficient -> creates a product

Explain Plan option will show you an analysis of the execution plan calculation by the query optimizer

SQL DDL - CREATE (M06 L01)

Data Definition Language: Statements that CREATE and MODIFY database structures (tables, etc.)

Create, Alter, Drop

Create

Creates a new table or view

defines table name and its columns
defines data type, length for each column
defines constraints for each column
Usually drop table (if it exists) before creating

CREATE TABLE <table_name> (
  <column_name> <DATATYPE(L)>,
  <column_name> <DATATYPE(L)> NOT NULL,
  <column_name> <DATATYPE(L)> CONSTRAINT <constraint_name> <TYPE>
)

Example

CREATE TABLE shippers (
  ShipperID   INT NOT NULL,
  CompanyName VARCHAR(40) NOT NULL,
  Phone       VARCHAR(20) NOT NULL DEFAULT '0'
)

NOT NULL: Prevent inserting a row when the column has no value, can provide a default value.

DROP

Drops named DB table

DROP TABLE IF EXISTS <table_name>;

DATA TYPES available depend on the DB engine (MySQL, Oracle, Posgres, etc.)

CHAR: fixed width string, shorter strings get padded
VARCHAR: variable width string, longer strings get truncated, shorter strings does NOT store blanks
FLOAT: floating-point data type that stores approx. values for real numbers
DECIMAL: fixed-precision data type that stores exact values, often for dollar cents. DECIMAL(9, 2) means 9 total digits with 2 digits to the right of the decimal point.
INT: number w/o decimal places (also TINYINT, SMALLINT, etc)
BLOB: binary large object (binary image, etc)
DATE: Just year, month, day
DATETIME: Year, month, day, with time
TIMESTAMP
ENUM: like a small array
BOOLEAN: actually tinyint(1)

SQL DDL - ALTER (M06 L02)

ALTER allows you to change different characteristics of database structures like tables, columns, and views

Alter a table:

ADD or DROP columns
ADD or DROP constraints

Alter a column:

SET or DROP a default
SET a DATA_TYPE

-- Change table name
ALTER TABLE items RENAME TO products;

-- Change name of column
ALTER TABLE products
RENAME COLUMN itemCode TO itemRef;

-- Add column
ALTER TABLE products
ADD COLUMN scanCode VARCHAR(5) NULL;

-- Change column data type
ALTER TABLE products
MODIFY COLUMN itemCode CHAR(4);

-- Drop column
ALTER TABLE products
DROP COLUMN itemCode;

DML - Insert, Update, Delete (M06 L03)

Data Manipulation Language - Populates and modify the data

Insert, Update, Delete

Insert

Two formats:

-- if no column & value are specified, NULL or default is assigned)
INSERT INTO <table_name> (column, column, column)
VALUES (value, value, value);

-- must have a value or NULL for every column in table
INSERT INTO <table_name>
VALUES (value, value, value, value);

Update

UPDATE statement assigns new values to specific columns based on a condition

UPDATE <table_name>
SET <column> = <new_value>
WHERE condition;

If no condition is given, it updates all rows! (check if this is correct)

Example

UPDATE Employees
SET firstName = "timmy",
    title = "Mr."
WHERE employeeID = 21;

TRUNCATE

TRUNCATE statement removes all rows, but keeps structure of table

TRUNCATE TABLE <table_name>;

DROP

DROP statement removes all rows and the table structure (completely removes table)

DROP TABLE <table_name>;

DELETE

Removes rows in a table based on WHERE clause

DELETE FROM <table_name>
WHERE <condition>;

DELETE FROM Employees
WHERE employeeID IN (10, 20, 30);

NOTE: a DELETE without a WHERE is the same as TRUNCATE!

SQL Constraints (M07 L01)

https://www.youtube.com/watch?v=N8qQzSvA9TM
https://drive.google.com/file/d/1KVHoXCUgxAZkolJrFdH3AdJP0774WCdN/view?usp=drive_link
Constraints can be defined within the CREATE TABLE statement
Can be added to able after creation with ALTER TABLE statement

Five types of constraints:

PRIMARY KEY
NULL/NOT NULL
UNIQUE
CHECK
FOREIGN KEY

Primary key constraint

can be defined at column level if one column
- comes with unique constraint, not null constraint
Must be defined at table level if more than one column

CREATE TABLE persons (
  ID INT PRIMARY KEY,
  LastName VARCHAR(255) NOT NULL,
  FirstName VARCHAR(255) NOT NULL
);

CREATE TABLE persons (
  ID INT,
  LastName VARCHAR(255) NOT NULL,
  FirstName VARCHAR(255) NOT NULL, 
  Phone CHAR(10) NOT NULL,
  PRIMARY KEY (LastName, Phone)
);

To make a constraint modifiable (via ALTER), you must give it a name:

CREATE TABLE persons (
  ID INT,
  LastName VARCHAR(255) NOT NULL,
  FirstName VARCHAR(255) NOT NULL, 
  Phone CHAR(10) NOT NULL,
  CONSTRAINT PK_Person PRIMARY KEY (ID, LastName)
);

ALTER TABLE Persons DROP CONSTRAINT PK_Person;

ALTER TABLE Persons 
ADD CONSTRAINT PK_Person PRIMARY KEY (ID, LastName);

most shops always name constaints and have standards for naming them.

UNIQUE

May be defined at column level if one column

CREATE TABLE persons (
  ID INT PRIMARY KEY,
  LastName VARCHAR(255) NOT NULL,
  FirstName VARCHAR(255) NOT NULL,
  Email VARCHAR(255) UNIQUE
);

CREATE TABLE persons (
  ID INT PRIMARY KEY,
  LastName VARCHAR(255) NOT NULL,
  FirstName VARCHAR(255) NOT NULL, 
  Phone CHAR(10) NOT NULL,
  UNIQUE (LastName, FirstName)
  -- or with name
  CONSTRAINT UN_Name UNIQUE KEY (LastName, FirstName)
);

CHECK

Applies a condition to a column. Rules for conditions same as WHERE clause

CREATE TABLE persons (
  ID INT PRIMARY KEY,
  LastName VARCHAR(255) NOT NULL,
  FirstName VARCHAR(255) NOT NULL, 
  Age INT,
  CONSTRAINT CK_Age CHECK (Age > 18)
);

Will only insert if age is > 18

FOREIGN KEY

Defined at column level

CREATE TABLE persons (
  ID INT PRIMARY KEY,
  LastName VARCHAR(255) NOT NULL,
  FirstName VARCHAR(255) NOT NULL, 
  DepartmentNumber INT FOREIGN KEY
     REFERENCES Department (DeptID) NOT NULL,
  Age INT,
);

Table level: allows you to give name

CREATE TABLE persons (
  ID INT PRIMARY KEY,
  LastName VARCHAR(255) NOT NULL,
  FirstName VARCHAR(255) NOT NULL, 
  DepartmentNumber INT,
  Age INT,
  CONSTRAINT FK_Department FOREIGN KEY (DepartmentNumber)
     REFERENCES Department (DeptID)
);

Can add later with an Alter:

ALTER TABLE Persons
ADD CONSTRAINT FK_Department
FOREIGN KEY (Department)
REFERENCES Department (DeptID);

Foreign key constraints used to maintain Referential Integrity (RI). There are rules that can be set on Parent tables for when an update or delete is done, for what to do with the child row:

SET NULL: sets child value NULL
SET DEFAULT: sets child value to column default
CASCADE: deletes or updates the child (if parent is deleted, deletes child, or if parent id is updated it will update child ref id)
NO ACTION/RESTRICT: prevents action on table

CREATE TABLE persons (
  ID INT PRIMARY KEY,
  LastName VARCHAR(255) NOT NULL,
  FirstName VARCHAR(255) NOT NULL, 
  DepartmentNumber INT,
  Age INT,
  CONSTRAINT FK_Department FOREIGN KEY (DepartmentNumber)
     REFERENCES Department (DeptID)
     ON DELETE SET NULL
     ON UPDATE CASCADE
);

Depending on the data model and the optionality, the foreign key can be NULL.

SQL Triggers (MO7 L02)

Triggers are:

a pieces of SQL code stored with a table
associated with a table
associated with an event
the code fires when the event happens

Why use triggers

enforce business rules
moves code from an application program to the DB
Performance improvement - all work done on server
convenient for DB people to store these rules in the DB and not the application, helps to enforce business rules. Advantagious from the DB perspective to store code related to the DB or effects the DB in the database itself instead of the app.
Gives DB more control over DB
Note: trigger is stored with the table, so when table is dropped trigger is dropped

Trigger events:

Insert, update, delete

Trigger timer

Before, after, instead of
Depends on the DB on what is available

Instead of: E.g. Instead of doing an insert, fire the trigger

CREATE TRIGGER trigger_name [BEFORE|AFTER] event(DELETE, etc)
ON table_name trigger_type
BEGIN
  -- trigger_logic
END;

First, specify the name of the trigger after the CREATE TRIGGER clause.
Next, use either BEFORE or AFTER keyword to determine when to the trigger should occur in response to a specific event e.g., INSERT, UPDATE, or DELETE.
Then, specify the name of the table to which the trigger binds.
After, specify the type of trigger using either FOR EACH ROW or FOR EACH STATEMENT. We will discuss more on this in the next section.
Finally, put the logic of the trigger in the BEGIN ... END block.

Row level trigger vs. statement level trigger

There are two types of triggers: row and statement level triggers.

A row level trigger executes each time a row is affected by an UPDATE statement. If the UPDATE statement affects 10 rows, the row level trigger would execute 10 times, each time per row. If the UPDATE statement does not affect any row, the row level trigger is not executed at all.

Different from the row level trigger, a statement level trigger is called once regardless of how many rows affect by the UPDATE statement. Note that if the UPDATE statement did not affect any rows, the trigger will still be executed.

When creating a trigger, you can specify whether a trigger is row or statement level by using the FOR EACH ROW or FOR EACH STATEMENTrespectively.

Special features

When trigger is fired, DBMS supplies:

OLD and NEW values for the update
NEW values for inserts
OLD values for deletes

You can reference OLD and/or NEW value of a column within the code of the trigger

Example:

Archival data before a delete
E.g. move data to an archival orders table

-- Gets fired when an Orders record is deleted
CREATE TRIGGER before_order_delete
  BEFORE DELETE ON Orders
  FOR EACH ROW
BEGIN
  INSERT INTO OrdersArchive
  SET OrderID = OLD.OrderID,
      CustomerID = OLD.CustomerID,
      EmployeeID = OLD.EmployeeID,
      OrderDate = OLD.OrderDate,
      ArchiveDate = NOW();
END;

Example from Lab:

CREATE TRIGGER update_student_gpa
AFTER INSERT ON ClassGrade
FOR EACH ROW
BEGIN
  UPDATE Student
  -- Use subquery to calculate the new GPA and then use result to set the student's gpa column.
  SET gpa = (SELECT SUM(Class.units * ClassGrade.grade)/SUM(units)
             FROM ClassGrade
             LEFT JOIN Class ON ClassGrade.cID = Class.cID
             -- New.sID is the student ID from the newly inserted ClassGrade
             WHERE ClassGrade.sID = NEW.sID)
  -- Make sure to update the student referenced in the newly inserted ClassGrade
  WHERE Student.sID = NEW.sID;
END;

SQL Case and View (MO7 L03)

CASE

CASE expression allows SQL to process conditionals like IF/THEN/ELSE in other programming languages (there is no if/then/else in SQL)

The CASE is an expression that can be used anywhere in teh SQL where an expression is allowed

CASE
  WHEN <condition_1> THEN <result_1>
  WHEN <condition_2> THEN <result_2>
  WHEN <condition_3> THEN <result_3>
  ELSE <else_result>
END

If a WHEN condition is true, the WHEN ends with that result
If the WHEN condition is false, control passes to next WHEN

Example:

-- adds "category" to answer set
SELECT productID, productName, unitPrice
CASE
  WHEN unitPrice < 20 THEN "Economy"
  WHEN unitPrice < 80 THEN "Standard"
  ELSE "Premium"
END category
FROM Products;

Views

VIEW is an empty shell of a table definition
The view contains no data until it's queried
Kind of like a "Virtual Table"
Each time view is queried, the underlying query that populates the view is re-executed
Data in the view table does not persist

Why use views?

Security, maintaining confidentiality
- View can prevent unauthorized users from seeing data that must be kept secure or confidential
Complexity
- The view can hide complex SQL from unauthorized or inexperienced users
- Can instruct people to use views

-- Hiding salary from an employees table
CREATE VIEW EmployeeSecure AS
  SELECT EmployeeID, LastName, FirstName, HireDate
  FROM Employees;

-- Using a view
SELECT * from Employees;

CREATE VIEW <view_name> AS
  <view_query>;

Auto-increment and UNION (MO7 L04)

Auto-increment

Can assign the AUTO_INCREMENT "constraint" to a column when creating a table
Auto increment typically is used as surrogate key when no other keys are available
Auto-increment columns are ints that automatically increment by 1 when a new row is inserted
Created and managed by DB
Guarantees a unique key value for each new row

CREATE TABLE Shoppers (
  ShopperID INT NOT NULL PRIMARY KEY AUTO_INCREMENT,
  ShopperName VARCHAR(40) NOT NULL
);

Auto-increment keys are not reused when a row is deleted and a new one is inserted. It goes up from the last used key

UNION

SQL UNION operator allows SQL to combine multiple answer sets into a single answer set.

When combining multiple answer sets into one, you must be sure that both sets contain the same number of columns and that the columns in the sets have the same data types.

-- First query
SELECT categoryName, SUM(unitsInStock) AS "Total units"
FROM Categories C
JOIN Products P ON C.categoryID = P.categoryID
GROUP BY categoryName;

-- Second query
SELECT "Total", SUM(unitsInStock) AS "Total units"
FROM Products;

-- Unioned query
-- Both have same number columns and they are the same datatype
SELECT categoryName, SUM(unitsInStock) AS "Total units"
FROM Categories C
JOIN Products P ON C.categoryID = P.categoryID
GROUP BY categoryName
UNION
SELECT "Total", SUM(unitsInStock) AS "Total units"
FROM Products;

Understanding Rails Polymorphic Associations: A Case Study

Felice Forby — Tue, 16 Jul 2024 13:21:04 +0000

I recently got to implement a polymorphic table in Rails at work. I've read about polymorphism a few times in books or blogs, but I never quite understood it. Having a real-life situation to apply the concept to at work, along with some conversations with my team's lead engineer finally made it click!

A lot of the examples in other articles and in even in the documentation are somewhat contrived, so I'd like to share what I did on the job as a real-world mini case study in hopes that this helps someone else.

The situation

My company provides employee benefits (e.g. dental and vision insurance) for other companies and we have many types of users that can interact with our platform such as company HR admins, brokers who sell insurance, and the members who have insurance. Naturally, we need to send a lot of emails to these people. The goal of my work project was to consolidate the different email categories we have and better keep track of the recipients for emails that we send out. For example, we have emails related to invoicing and insurance renewals, and they are sent to different people depending on their role within the system.

In regards to modeling, I needed to model a table that represented recipients of a set of emails under a certain category, where one category like "Invoicing" could contain several different specific emails. I named the model EmailCategoryRecipient, and each "recipient" could be associated with different kinds of user profiles we have in the system: a CompanyContact (e.g. an HR person at a company) and a BrokerProfile (e.g. the broker who sold the insurance to the company). An EmailCategoryRecipient belongs to a profile, where the profiles could be different classes.

Considering the model relationships, it sounded exactly like the kind of situation a model with a polymorphic association could help with!

The polymorphic association and database table

Creating the polymorphic association

A polymorphic association lets you create a model that can belong to more than one class, but uses only one belongs_to association instead of multiple. This multifaceted association is usually represented by the name of the concept + the -able prefix. In my case, the associations were different kinds of profiles so I called it profileable, but you can name these associations anything you want.

Here's what it would look like to set up the polymorphic relationship in the models I mentioned above:

class EmailCategoryRecipient < ApplicationRecord
  belongs_to :profileable, polymorphic: true
end 

class CompanyContact < ApplicationRecord
  has_many :email_category_recipients, as: :profileable
end

class BrokerProfile < ApplicationRecord
  has_many :email_category_recipients, as: :profileable
end

Again, even though EmailCategoryRecipient only has one belongs_to for profileable, it can represent different types of classes—a CompanyContact or a BrokerProfile. This is possible because I used the polymorphic: true option on the belongs_to association. As you can imagine, there could be many other things that need to have email recipients associated to them as well, like a Member or an Admin profile. Any number of these associations could be captured in the polymorphic profileable attribute.

Creating a migration to set up the polymorphic association

To make the above relationships work, you need to create a migration that sets up a table that can handle the polymorphic associations. Rails gives us handy shortcuts to do so. It would look something like this:

class CreateEmailCategoryRecipients < ActiveRecord::Migration[7.1]
  def change
    create_table :email_category_recipients do |t|
      t.string :category_name # just to keep track of category, this has nothing to do with the polymorphic piece
      t.references :profileable, polymorphic: true

      t.timestamps
    end
  end
end

Even though it's only one line, the t.references :profileable, polymorphic: true will actually create two columns and an index. The columns created are an *_id column and *_type column which are based on the polymorphic name. (in this case profileable). This one-liner is a nice shortcut method, but you could also write the migration explicitly like below. It would be equivalent to the migration above:

class CreateEmailCategoryRecipients < ActiveRecord::Migration[7.1]
  def change
    create_table :email_category_recipients do |t|
      t.string  :category_name # again, this is just an additional attribute not related to polymorphic columns
      t.bigint  :profileable_id
      t.string  :profileable_type

      t.timestamps
    end

    add_index :email_category_recipients, [:profileable_type, :profileable_id]
  end
end

Let me explain the two columns profileable_id and profileable_type. The profileable_id holds the id (primary key) of the associated object while the profileable_type keeps track of what kind of object it is, which is the stringified class name of that object ("CompanyContact" or "BrokerProfile" in this case). We need the *_type column in addition to the *_id column because Rails needs to know what database table to look in to fetch the associated record, as the different types are stored in separate database tables. When you assign an object as a profileable, Rails will take care of filling out these two columns automatically with that object's id and class.

Something to think about: Polymorphism is not the only way to do this

While polymorphic relationships are pretty cool and can provide an elegant solution, I want to call out that you don't actually need to use it every time you have to associate multiple similar classes to a model. In fact, there are a lot of times when it's not the right tool for the job.

The alternative is to just associate each thing separately with the standard belongs_to and respective *_id column.

Modeling EmailCategoryRecipient as a non-polymorphic relationship would look like this:

class EmailCategoryRecipient < ApplicationRecord
  belongs_to :company_contact
  belongs_to :broker_profile
end

class CompanyContact < ApplicationRecord
  has_many :email_category_recipients
end

class BrokerProfile < ApplicationRecord
  has_many :email_category_recipients
end

The migration for the above setup would look like this:

class CreateEmailCategoryRecipients < ActiveRecord::Migration[7.1]
  def change
    create_table :email_category_recipients do |t|
      t.string :category_name
      # t.belongs_to is another shortcut method that will create indices for you too, unless specified not to
      t.belongs_to :company_contact
      t.belongs_to :broker_profile

      t.timestamps
    end
  end
end

Or alternatively with out using the shortcut t.belongs_to:

class CreateEmailCategoryRecipients < ActiveRecord::Migration[7.1]
  def change
    create_table :email_category_recipients do |t|
      t.string :category_name
      t.bigint :company_contact_id
      t.bigint :broker_profile_id

      t.timestamps
    end

    add_index :email_category_recipients, :company_contact_id
    add_index :email_category_recipients, :broker_profile_id
  end
end

If you were to go this route, you would need to assign any BrokerProfile objects directly to the EmailCategoryRecipient's broker_profile attribute (or the id to the broker_profile_id) and the same goes for CompanyContact.

When would you NOT want to use polymorphism

The big benefits of using polymorphic associations are that it helps keep the code clean, simple, and flexible.

That being said, I think that polymorphism can also make your code more abstract and therefore harder to understand at a glance, especially for people who aren't familiar with how polymorphic tables work or for someone who doesn't yet understand that model's relationship to other models. For example, it's not immediately obvious what classes profileable should refer to unless you just "know" from the get go. You may need to go searching through the codebase to find what classes can be associated with the polymorphic one.

Another thing to think about is whether the polymorphic objects you plan to associate with polymorphic type are similar or not. That is, do they share similar interface (attributes and methods) in places where it matters? It depends on the use case, but it may be extra hassle if the different classes aren't similar in their interface.

For example, if you needed to pull email off of CompanyContact and BrokerProfile but one model used the attribute name email and the other email_address, you would have to check the class type to figure out what method could be called, alias the method in one class to match the other, or come up with another solution to avoid getting errors if the wrong method gets called on the wrong object. If you need to do this for multiple attributes on these classes, it may defeat the purpose of using a polymorphic association in the first place.

You could also run into data integrity issues if the "wrong" kind of object gets saved into the polymorphic table or if a non-existent object gets saved into the table. With polymorphic associations, Rails does not check the referential integrity of the record, that is, does it actually exist in the database. Queries will generally be slower as well, since Rails needs to check both the id and the type of the object.

The final outcome

To bring this case study to an end, I want to touch on the final decision I made, which was actually not to use the polymorphic association. I ended up using explicit id columns for each associated object instead. Though I had already migrated the new tables, it was easy to changed because we hadn't started using them yet.

There are a couple reasons why I went the other direction. The main reason is that I found out we needed to have an additional association with the EmailCategoryRecipient model that was called PlatformConfig. The purpose of this model is to store configurations of the insurance partner platforms we work with, including the contact email for that partner. For our company, it represents another kind of recipient, but it is not a type of profile, and therefore it didn't make sense to consider it a profileable type. It also seemed awkward to have both a polymorphic entity for profiles and a separate non-polymorphic entity for the platforms.

The second reason is that the CompanyContact and BrokerProfile models were originally created at different times for different purposes. CompanyContact was implemented long before our concept of a user "profile" was even introduced. For our use case, it would have been ideal if we could "trust" that the different profileable objects have similar interfaces, but that wasn't necessarily the case, so we decided the explicit belongs_to relationships were more appropriate.

One of the drawbacks here is that when we need to associate another type of profile to EmailCategoryRecipient in the future, we will need to change the table in order to add another belongs_to relationship. On the other hand, having explicit relationships makes it more obvious what kind of object we are dealing with at any given time.

References

Rails documentation

Linux Command Line Notes

Felice Forby — Mon, 15 Jan 2024 14:33:14 +0000

Reference for basic command line commands for Linux, because I always forget a lot of these.

Show current working directory

pwd

See username

whoami

Changing directories

Move to root/top directory

cd /

Move to user home directory

cd ~

or just

cd

Go up one directory level

cd ..

Print to screen

echo "Hello world!"

Creating directories and file

Create new directory

mkdir new_directory

Create multiple directories

mkdir dir1 dir2 dir3 dir4

You can't make new nested directories with mkdir. To do so, use the -p flag for "make parent directories"

mkdir -p new_directory/test_files/dir1

Create new file

touch new_file.txt

Use redirect to create simple files for testing etc. This will create a file if it's not already there. If there is already a file with the same name present, it will overwrite it so be careful!

echo "Hello world" > test.txt

Appending to a file

Using > to add something to a file will overwrite what was there before. Use >> to append to the end of file without overwriting everything.

echo "Appending some text!" >> myfile.txt

View directory contents

List all directories and files in current working directory excluding hidden ones

ls

Also show hidden files:

ls -a

See file permissions and more info (long format)

ls -l

Viewing files

Use cat to simply print the all the contents to the screen

cat config.txt

This can be done with multiple file names to see contents of multiple files

cat config.txt test.txt hello.txt

Use the less pager program to view files in an interactive pager.

less super_long_text.txt

Using Wildcards * and ?

? will match any single character.

For example, if you have multiple files like test_1.txt, test_2.txt and test_3.txt, you could print out all files like so:

cat test_?.txt

* will match zero or more characters.

For example, remove all mp3 files:

rm *.mp3

Moving and renaming files and directories

Use mv to move or rename files

mv <file_to_move> <destination_to_move_it>

Example: move test.txt to the testing directory one level above

mv text.txt ../testing

You can move multiple files/directories at once. List all the files/directories to move first. The last item will serve as the destination directory. The command below will move file.txt, dir1, and file2.txt to the dir2 directory.

mv file.txt dir1 file2.txt dir2

Example: rename test.txt to unit_tests.txt

mv text.txt unit_tests.txt

Example: rename testing directory to unit_tests

mv testing unit_tests

Copying file

Copy to a new directory

cp <file_to_copy> <direcory_to_copy_to>

Example: Make a copy of config.txt in the backup directory

cp config.txt backup

Copy a file to the same directory with a new name

cp <file_to_copy> <new_name_for_copied_file>

Example: Create a copy of essay.txt in the current directory and name it essay_edit.txt

cp essay.txt essay_edit.txt

Removing (Deleting) files and directories

CAUTION: These commands will permanently delete things without a way to retrieve them, so make sure you're very careful!

Delete one or more files

rm test1.txt
rm text2.txt test3.txt

Delete a directory. This only works for empty directories.

rmdir my_folder

Delete a directory and any empty sub-directories using the -p flag. This will not delete files contained in the directories. Below would delete the my_folder directory and any empty subfolders it contains.

rmdir -p my_folder

Remove all directories and files in the given location (Dangerous):

rm -r folder_to_delete

Word and line counts

Show line count, word count, and byte count of a file (in that order)

wc test_1.txt
>   5      10      56 test_1.txt

The above output tells us that test_1.txt has 5 lines, 10 words, and 56 bytes.

To show only line count, use the -l flag

wc -l test_1.txt
>   5 test_1.txt

Sort command

Sort a file by line, that is, matching lines will be grouped together.

sort my_file.txt

Piping

Pipes | allow you to feed the output of one command into the next command.

Example: See how many files/folders there are in the user's home directory

ls ~ | wc -l

ls ~ would list all the files in the directory. Putting a pipe after it feeds the output into the wc word count command.

Example: Count the number of unique lines in a file. Note that uniq will give you only the unique lines in a file, but it only does so if the duplicated lines are next to each other.

sort my_file.txt | uniq | wc -l

`man`: See documentation on a command

Get info about how to use a command and the available options with man

man ls

Run a command as the super user

Use sudo followed by the command you want to run. Do this only when absolutely necessary!

Sidekiq's sidekiq_retries_exhausted hook

Felice Forby — Thu, 12 Aug 2021 13:07:41 +0000

sidekiq_retries_exhausted is a Sidekiq hook that you can use to do something after Sidekiq has used up all of its retries but the job still failed. It's a good way to make sure you send a failure notification or log an error that might be causing the job to fail instead of it just failing silently.

In the worker, you can set a specific number of retries if you want with sidekiq_options retry: <some_number>. The default is 25 times.

Here are a couple of examples but there are ton of ways to configure this which can be found in the documentation.

# Retry 3 times before giving up
sidekiq_options retry: 3
# Don't retry at all
sidekiq_options retry: false

If the job has used up (exhausted) all of its retries, Sidekiq moves it to the "Dead set" and it will eventually get discarded.

Sidekiq will call the sidekiq_retries_exhausted hook right before moving the job to the dead set if you define it in the worker. sidekiq_retries_exhausted takes a block and receives the queued message as an argument so you can use it to compose a log message. See below for an example:

class MyWorker
  include Sidekiq::Worker
  sidekiq_options retry: 3

  sidekiq_retries_exhausted do |msg, exception|
    # example with using Rails' logger
    Rails.logger.warn("Failed #{msg['class']} with #{msg['args']}: #{msg['error_message']}", error: exception)
  end

  def perform(my_arguments)
    # do some work
  end
end

This hook is worker specific, so you would define sidekiq_retries_exhausted for each worker you need. There is also a way to send a job "death" notice for all workers globally by adding some configuration in the initializer (in Rails that would be the config/initializers/sidekiq.rb file).

Sidekiq.configure_server do |config|
  # other config stuff...

  config.death_handlers << ->(job, ex) do
    Rails.logger.error "Uh oh, #{job['class']} #{job["jid"]} just died with error #{ex.message}."
  end
end

References

Rename a Rails app (including database, Github, and Heroku names)

Felice Forby — Fri, 10 Jul 2020 01:13:32 +0000

Recently I started working on a Rails project without having a good name picked out, so I gave the application a temporary one for the time being. I ended up with a Github repository and a Heroku app that used that temporary name, but after finally thinking of the perfect name, I naturally wanted to update it everywhere. This is how I did it!

I'll go over how I changed the repository name on Github and the name of the app on Heroku, and how you can go about changing the name of the databases used by Rails.

For reference, this is the setup of my app:

Rails 6.0.3.2
Ruby 2.7.1
Code on Github
Deployment to Heroku
PostgreSQL database in both production and development

Rename the Github repository

To change the name on Github, simply go to the repository page online, navigate to repository's Settings page and change the name using the "Repository name" field.

Github will take care of forwarding to the new URL whenever the old URL is accessed, for example when you push or pull, but I think it would be better to make sure the remote URLs on your local machine also match up.

To update the remote on your computer, first, grab the new url from the repository page on Github, which you can get from the "Clone with SSH" button.

It should look something like this:



git@github.com:your-username/reponame.git

Next, navigate to the directory where your Rails app lives on your local machine.

You can check the currently registered remote URL that connects the git repository to Github with the following command (assuming remote is named "origin", which it should be unless you changed it):



git config --get remote.origin.url

At this point, it should still display the old remote URL, something like git@github.com:your-username/old-repo-name.git.

To update it, enter the following command using the URL you copied from Github:



git remote set-url origin git@github.com:your-username/new-reponame.git

You can double check that it got updated by running the git config --get remote.origin.url command again.

Okay! That should take care of the Github side! Next, let's update things on the Heroku side.

Rename the app on Heroku

This is done easiest from the command line because it will also automatically update the remote URL for Heroku as well. Type the following command in the command line from within the app's directory, replacing new-name with new name of your app:



heroku apps:rename new-name

Simple as that! You can check to make sure the remote URL for Heroku has been updated with the following command:



git config --get remote.heroku.url

It should look something like https://git.heroku.com/new-name.git.

If you navigate to your Heroku dashboard online, you will see that everything has been updated!

Well, almost everything... If you had the Github repository connected to Heroku under the "Deploy" settings, it will still have the old Github URL. Though Github will automatically redirect any access to this URL, you might want to update it here too. Just use the "disconnect" button to disconnect and then reconnect to the newly renamed repository.

Rename the Rails databases

Although you don't technically have to rename the databases, you may want to anyways just to be consistent.

When you first ran rails new command, it creates a file for database configuration, the config/database.yml file. The databases are named after the app name you passed along to the rails new command, so in the database.yml file you will find settings that look something like this (where app_name is the name of the app):



# config/database.yml

# ... other code

development:
  <<: *default
  database: app_name_development

test:
  <<: *default
  database: app_name_test

production:
  <<: *default
  database: app_name_production
  username: app_name
  password: <%= ENV['APP_NAME_DATABASE_PASSWORD'] %>

Development/Test database configuration

Depending on how you set up your data for the development environment (if at all), you can run into a few different situations:

You have a db/seeds.rb file that sets up all the data.
You did not use the db/seeds.rb file, but the data created while testing out the app in development isn't that important and you don't care if it gets erased.
You did not use the db/seeds.rb file, but you want to keep the data created while testing out the app in development, so it should NOT get erased.

Situation 1: You have a `db/seeds.rb` file for all your data

First, drop (= destroy) the database with this rails command:



rails db:drop

If successful, you'll see the following output:



$ rails db:drop
Dropped database 'app_name_development'
Dropped database 'app_name_test'

Rename the development and test databases in the config/database.yml file, replacing new_name with the actual name you want to use:



# config/database.yml

# ... other code

development:
  <<: *default
  database: new_name_development

test:
  <<: *default
  database: new_name_test

# ... more code

Run rails db:setup to recreate the databases and fill it with your seed data.

That's it! Everything should work like before.

Situation 2: You don't have seed data, but don't care if everything is erased

First, drop (= destroy) the database with this rails command:



rails db:drop

If successful, you'll see the following output:



$ rails db:drop
Dropped database 'app_name_development'
Dropped database 'app_name_test'

Rename the test and development databases in the config/database.yml file as described above.

Then run rails db:create and rails db:migrate to set up a sparkling new database with a new name.

Situation 3: You don't have seed data, but you want to make sure no data gets erased.

I am using a PostgreSQL database in my development environment and have PostgreSQL installed locally, so this explanation will be specific to this setup. If you're using a different database locally like Sqlite, you'll have to look up the specific methods for that database.

Using a database dump (backup) file

If you do need to backup data you had for development, you can use the pg_dump tool provided by your PostgreSQL database.

I used this tutorial, Backing Up and Restoring A Database, as a reference, so check it out for more in-depth explanation.

Create the database dump file

Create the backup file with the following command on the command line from within the Rails app directory, replacing app_name_development with the actual name of your database listed in the config/database.yml file:



pg_dump -F t app_name_development > development_backup.tar

-F t formats the file into a tar file. development_backup.tar is the name for the backup file, which you can name it anything you want.

Learn more about the pg_dump command in the PostgreSQL documentation

After the running the above command, a database backup file should have been created in the root directory of your Rails app.

Drop the current database

Drop (= destroy) the database with the Rails command (this will erase everything, so make sure your backup was created):



rails db:drop

If successful, you'll see the following output:



$ rails db:drop
Dropped database 'app_name_development'
Dropped database 'app_name_test'

If you run the Rails server and try to access the app, you'll also see a ActiveRecord::NoDatabaseError.

Rename and recreate the database

Rename the development and test databases in the config/database.yml file, which still contains the old database names.



# config/database.yml

# ... other code

development:
  <<: *default
  database: old_app_name_development

test:
  <<: *default
  database: old_app_name_test

Rename all the things with the old_app_name to the new app name.

After that, run rails db:create in the command line to create the newly named database. You will see output like this:



$ rails db:create
Created database 'new_name_development'
Created database 'new_name_test'

Restore the database from the backup file

To restore from the database backup, you can use pg_restore command, replacing new_name_development with actual name in your database.yml:



pg_restore -d new_name_development development_backup.tar

The -d new_name_development option lets you connect to given database (here it's new_name_development) and restore directly into it. development_backup.tar specifies the name and location of the dump file that you created earlier.

And there you go! Your development and test database are now renamed and the previous data has been restored for development.

Production database configuration

The production database is the one that Heroku uses when running the deployed app. Rails generated the following production database configuration when I first created the app:



# config/database.yml

# ... other code

production:
  <<: *default
  database: app_name_production
  username: app_name
  password: <%= ENV['APP_NAME_DATABASE_PASSWORD'] %>

In my case, I just have a basic Heroku setup and don't have any custom database configurations. If that is the case, then you don't actually need this configuration because Heroku uses it's own configuration through an environment variable set as ENV["DATABASE_URL"], which will override the above configuration in the yaml file.

In other words, renaming the production database here doesn't do anything. Instead, I would recommend changing the configuration to explicitly say that you are using the environment variable (also recommended in the Rails Guides).

In fact, you may have a comment in your database.yml just above the production settings that tells you how to do this depending on how the Rails app was initially set up:



# config/database.yml

# ... Other settings

# On Heroku and other platform providers, you may have a full connection URL
# available as an environment variable. For example:
#
#   DATABASE_URL="postgres://myuser:mypass@localhost/somedatabase"
#
# You can use this database configuration with:
#
#   production:
#     url: <%= ENV['DATABASE_URL'] %>

So, as a last step, change the production database configuration inside database.yml so that it looks like this:



# config/database.yml

# ... Other settings

production:
  url: <%= ENV['DATABASE_URL'] %>

And we are finished! Everything should now be renamed to the correct app name :D

References

Stopping a Webcam with JavaScript

Felice Forby — Mon, 30 Mar 2020 08:14:47 +0000

I recently had to manually get a running web camera to turn off using JavaScript for a project at work.

I had a hard time figuring out JavaScript's MediaStream API so here are some quick notes on how I got the camera to stop.

If the camera is running through a video element, you can stop the video by getting its MediaStreamTrack object and using the stop() method:

const video = document.querySelector('video');

// A video's MediaStream object is available through its srcObject attribute
const mediaStream = video.srcObject;

// Through the MediaStream, you can get the MediaStreamTracks with getTracks():
const tracks = mediaStream.getTracks();

// Tracks are returned as an array, so if you know you only have one, you can stop it with: 
tracks[0].stop();

// Or stop all like so:
tracks.forEach(track => track.stop())

Another way to get all the MediaStreams is to use mediaDevices.getUserMedia() which is called on navigator tracks. It prompts the user for permission (if not already granted) to access the media devices. It will return a Promise so you can write the necessary code within the Promise's then:

navigator.mediaDevices.getUserMedia({video: true, audio: false})
  .then(mediaStream => {
    const stream = mediaStream;
    const tracks = stream.getTracks();

    tracks[0].stop;
  })

Make sure you only call getUserMedia once or stop() won't work, so if your code or a library you're using calls getUserMedia on the page to activate a camera, then you probably won't be able to use this method.

References

QR Code Reader on Rails

Felice Forby — Fri, 21 Feb 2020 00:06:40 +0000

Intro and getting started

I recently had to implement a QR code reader in Rails at work and in this article, I'll take you through how I did it by creating a demo featuring two different ways of handling scanned QR codes: One simply scans a QR code and displays the scanned data on the screen and the other sends the QR data to a Rails controller for processing.

Let's get started right away! We'll do so by creating a new Rails project:

rails new qr-code-reader-demo

Next, we'll install a JavaScript library that will allow us to scan QR codes with a video camera on a phone or computer.

Install the QR code reader: ZXing-js

After research different QR code scanning libraries, I decided to use the ZXing JS library.

Why ZXing?

Ideally, it would have been nice to use a ruby gem. Although there are a few QR code reader gems available, they are no longer maintained (no updates for a couple of years).

The next option was using a JavaScript library. There are several JS libraries that handle QR code scanning, but ZXing is actively maintained and is a popular choice among developers. ZXing-js is actually a port of an "open-source, multi-format 1D/2D barcode image processing library implemented in Java."

Let's get it installed into Rails.

Simply use npm to install the package and then update yarn:

# Install with npm
npm i @zxing/library --save

# Update yarn packages
yarn install --check-files

Basic QR code reader: Scan and display on the screen

First, we'll create a super simple scanner that just takes the data decoded from the QR code and displays it on the page.

Let's set up a route and a controller. You can, of course, name the route and controller whatever you want, but I'm going to make the path /basic-qr-code-reader and route it the #index action of a controller called the BasicQrCodesController:

# config/routes.rb

Rails.application.routes.draw do
  get 'basic-qr-code-reader', to: 'basic_qr_codes#index'
end

# app/controllers/basic_qr_codes_controller.rb

class BasicQrCodesController < ApplicationController
  def index
  end
end

The controller won't be doing anything special except for rendering a view, so it's just a barebones action.

Here is the basic JavaScript code—borrowing from one of ZXing's demos—that will get the job done. We'll put it into a file under app/javascript/packs/:

// app/javascript/packs/basic-qr-code-reader.js

import { BrowserQRCodeReader } from '@zxing/library';

const codeReader = new BrowserQRCodeReader();

codeReader
  .decodeFromInputVideoDevice(undefined, 'video')
  .then((result) => {
    // process the result
    console.log(result.text)

    document.getElementById('result').textContent = result.text
  })
  .catch(err => console.error(err));

Here, codeReader is an instance of the ZXing's BrowserQRCodeReader class. In our case, we want to use a camera on some kind of device, so we'll use the decodeFromInputVideoDevice() method, which takes a device ID and a video element id as arguments. Passing in undefined chooses the default camera (if there are multiple cameras, you could allow the user to choose which one they want to use, for example. Check ZXing's documentation for more info).

decodeFromInputVideoDevice() will return a promise with the data (a string) that was decoded from the QR code.

In our HTML view, we need to make sure we have a video element with the given id (in our case it's just video). The JavaScript will decode the QR code from there.

Also, since we plan on displaying the result on the page, we need a place to put it. Examining the JavaScript above, you can see that the result is going to be injected into the HTML via an element that has an id of result:

document.getElementById('result').textContent = result.text

Here is a basic view that includes all of the necessary elements as well as our QR code reader JavaScript inserted with a Rails javascript_pack_tag:

<%# app/views/basic_qr_codes/index.html.erb%>

<h1>QR Code Reader Demo</h1>

<div>
  <video id="video" width="500" height="400"></video>
</div>

<label>Result:</label>
<pre><code id="result"></code></pre>

<%= javascript_pack_tag("basic-qr-code-reader") %>

And, that's it for the basic version! Start up the rails server with rails s and navigate to http://localhost:3000/basic-qr-code-reader. Try scanning a QR code and it should appear right there on the screen.

QR Code Reader on Rails: Processing scan data in Rails

The basic QR code scanner above is fun to play around with but it doesn't let us doing anything with the data we decoded.

In this section, we're going to get the JavaScript to handover the code data to Rails so we can process it and go further.

For this demo, we'll be set up a simple ActiveRecord model and controller that lets us use the data to create QR code objects and save them to the database. We'll also have a page that shows a history of our most recent scans.

Setting up a QR code model

Let's start off by creating a model called QrCode and database table where we can save the data.

Run rails g migration CreateQrCodes data:string and then open up the generated file to check it's contents:

# Migration for QrCodes

class CreateQrCodes < ActiveRecord::Migration[6.0]
  def change
    create_table :qr_codes do |t|
      t.string :data

      t.timestamps
    end
  end
end

Run rails db:migrate to set up the table.

For the model, we just need the bare minimum for now:

# app/models/qr_code.rb

class QrCode < ApplicationRecord
end

Initial routes and controller set up

To get things moving, we need to add some routes and a couple of controller actions.

We'll keep the flow basic: Open the scanner camera and get the data (new action), use the data to create a QrCode object (create action), and display the newly scanned QR code data (show action).

Add the necessary routes to routes.rb with the following line:

resources :qr_codes, only: [:new, :create, :show]

The routes.rb should look like this now:

# config/routes.rb

Rails.application.routes.draw do
  get 'basic-qr-code-reader', to: 'basic_qr_codes#index'

  resources :qr_codes, only: [:new, :create, :show]
end

We'll go ahead and stub out the controller actions, too. Create a file called qr_codes_controller.rb in the app/controllers directory:

# app/controllers/qr_codes_controller.rb

class QrCodesController < ApplicationController
  def new
  end

  def create
  end

  def show
  end
end

Okay, that takes care of the wiring. Now on to the JavaScript.

JavaScript: Send the QR code scan data to Rails

We need to do a few extra things in the QR code reader JavaScript in order to get it to communicate with our controller. (We'll put the new version of the QR reader JavaScript in another pack file, app/javascript/packs/rails-qr-code-reader.js, for the purpose of this demonstration.)

Here's the code and I'll explain below:

// app/javascript/packs/rails-qr-code-reader.js

import { BrowserQRCodeReader } from '@zxing/library';
import Rails from '@rails/ujs'; // Use to make an ajax post request to Rails

const codeReader = new BrowserQRCodeReader();

codeReader
  .decodeFromInputVideoDevice(undefined, 'video')
  .then((result) => {
    let qrDataFromReader = result.text;

    // Prepare a post request so it can be sent to the Rails controller
    let formData = new FormData();

    let qrCodeParams = {
      qr_data: qrDataFromReader
    };

    formData.append("qr_code_json_data", JSON.stringify(qrCodeParams));

    // Send QR code data as JSON to the 
    // qr_codes#create action using Rails ujs
    Rails.ajax({
      url: "/qr_codes",
      type: "post",
      data: formData
    });

  })
  .catch(error => {
    console.error(error);
  });

The plan is to send the QR code data to the create action of the QrCodes controller, which we'll do by making a POST request with ajax. To make that easier, we'll use Rails' ujs library. It needs to be imported into the JavaScript with import Rails from '@rails/ujs'; at the top of the file.

After getting the data from the code reader, we'll save it into variable:

let qrDataFromReader = result.text;

Next, we'll prepare the data with by creating a new JavaScript FormData object, parameterizing the data, and converting it to JSON:

// Create a new FormData object
let formData = new FormData();

// Prepare the data params
let qrCodeParams = {
  qr_data: qrDataFromReader
}; 

// Add the params to the FormData object, making sure to convert it to JSON
formData.append("qr_code_json_data", JSON.stringify(qrCodeParams));

Lastly, we just need to use the .ajax method of Rails ujs to send the data to the controller!

Rails.ajax({
  url: "/qr_codes",
  type: "post",
  data: formData
});

Note that the url is the POST path for the QrCodesController.

Set up a view for the QR code reader in app/views/qr_codes/new.html.erb and make sure the JavaScript pack gets included:

<h1>QR Code Reader Demo</h1>

<h2>QR Code Reader on Rails</h2>

<div>
  <video id="video" width="500" height="400"></video>
</div>

<%= javascript_pack_tag("rails-qr-code-reader") %>

Now that the scanner is ready, next we'll catch the scan data in the controller and process it.

Processing the QR code data

The data will arrive in the QrCodes controller create action. Because it comes in as JSON, we need to parse the JSON so we can use it. Let's add a before action that does that for us:

# app/controllers/qr_codes_controller.rb

class QrCodesController < ApplicationController
  before_action :set_qr_data, only: :create

  def index
  end

  def new
  end

  def create
  end

  def show
  end

  private

  def set_qr_data
    qr_code_params = JSON.parse(params[:qr_code_json_data]).with_indifferent_access

    @qr_data = qr_code_params[:qr_data]
  end
end

Here, JSON.parse gets the data into a usable form and .with_indifferent_access allows us to access the data using symbols (qr_code_params[:qr_data]) instead of quotes (qr_code_params['qr_data']). Not necessary, but I prefer symbols.

The params are available with params[:qr_code_json_data] because we named them that in the JavaScript above with this line: formData.append("qr_code_json_data", JSON.stringify(qrCodeParams));.

Inside of the QR code params, the qr data is available through the qr_data key, also because of the way we set up the data earlier in the JavaScript (let qrCodeParams = { qr_data: qrDataFromReader };).

After the everything is parsed, assign the data to an instance variable like so @qr_data = qr_code_params[:qr_data] and now we can treat the data as usual and use it to create new QrCode objects!

Let's do so in the create action and then redirect to a show page where we can see the new database entry.

# app/controllers/qr_codes_controller.rb

class QrCodesController < ApplicationController
  before_action :set_qr_data, only: :create

  def index
  end

  def new
  end

  def create
    qr_code = QrCode.create(content: @qr_data)

    redirect_to qr_code_path(qr_code)
  end

  def show
    @qr_code = QrCode.find(params[:id])
  end

  private

  def set_qr_data
    qr_code_params = JSON.parse(params[:qr_code_json_data]).with_indifferent_access

    @qr_data = qr_code_params[:qr_data]
  end
end

We just need to set up a basic show view where we can display the data, which we'll put in a new view file at app/views/qr_codes/new.html.erb:

<h1>QR Code Show Page</h1>

<p>QR data: <%= @qr_code.content %></p>
<p>Scanned on <%= @qr_code.created_at.strftime('%Y-%m-%d') %></p>

Nothing special here, but it lets us see the scanned data and the day it was scanned on.

It might also be nice to have an index page that lists all the recent scans, so let's set up the index action in the controller. We'll keep it simple and just show the 20 most recent scans:

# app/controllers/qr_codes_controller.rb

class QrCodesController < ApplicationController
  before_action :set_qr_data, only: :create

  def index
    @qr_codes = QrCode.order(created_at: :desc).first(20)
  end

  def new
  end

  def create
    qr_code = QrCode.create(content: @qr_data)

    redirect_to qr_code_path(qr_code)
  end

  def show
    @qr_code = QrCode.find(params[:id])
  end

  private

  def set_qr_data
    qr_code_params = JSON.parse(params[:qr_code_json_data]).with_indifferent_access

    @qr_data = qr_code_params[:qr_data]
  end
end

We also need the view for the index (app/views/qr_codes/index.html.erb), which we'll set up to be a simple list of scans that links to each scan's show page. It also has a button that links to the QR code scanner:

<h1>Recent QR Code Scans</h1>

<%= link_to 'New Scan', new_rails_qr_code_path, class: 'button' %>

<p><strong>20 most recent scans:</strong></p>
<ul>
  <% @qr_codes.each.with_index(1) do |qr_code, index| %>
    <li><%= "Scan #{index}: " %><%= link_to qr_code.content, rails_qr_code_path(qr_code) %></li>
  <% end %>
</ul>

And that's it! You just made a QR coder reader on Rails! I have the full code on Github if you'd like to explore.

This is a somewhat contrived and simple example, but there are plenty of applications for scanning QR codes and using their data. For example, for the project I did at work, the scanned QR codes contained the manufacturer serial numbers of certain machines. The serial codes were used to find specific models based on the serial number (which was done in the controller) and take the user to that model's information page for troubleshooting.

Anyway, have fun with it and enjoy :D

Using MySQL with Rails 6 and installing MySQL on Mac (macOS Mojave)

Felice Forby — Thu, 26 Sep 2019 06:34:19 +0000

I recently had to switch databases from Sqlite to MySQL after already creating a Rails app. I also had to install MySQL on my Mac.

This article goes over how I did this and fixed a weird OS-related error I got when trying to install the mysql gem.

Install MySQL on your Mac (with homebrew)

If you use homebrew for package management, you can install MySQL by using the following command on the command line:

brew install mysql

After it finishes installing, make sure you go over the instructions that homebrew gives you:

We've installed your MySQL database without a root password. To secure it run:
    mysql_secure_installation

MySQL is configured to only allow connections from localhost by default

To connect run:
    mysql -uroot

To have launchd start mysql now and restart at login:
  brew services start mysql
Or, if you don't want/need a background service you can just run:
  mysql.server start

You can set up a password with the mysql_secure_installation command.

You can start up MySQL right away with the brew services start mysql command.

Next, let's set up Rails to use MySQL!

Use MySQL with a brand new Rails app

If you haven't created your application yet, you can run the rails new command with a flag that configures your database to use MySQL instead of the default Sqlite:

rails new appname -d mysql

That will set up the Gemfile to use the mysql2 gem and make a config/database.yml with some default MySQL configurations.

Switching databases in an existing Rails 6 application

Rails 6 adds the handy rails db:system:change command that will automatically create the code needed to switch databases, which involves editing the config/database.yml file and adding the mysql2 gem to the Gemfile.

Use the following command from within your Rails application directory (you can also change to other databases, too. See [here](https://gorails.com/episodes/rails-6-db-system-change-command]:

rails db:system:change --to=mysql

It will ask you if you want to overwrite the config/database.yml file. Type y and press enter and you'll see that Rails has updated the following files:

force  config/database.yml
 gsub  Gemfile
 gsub  Gemfile

This adds the mysql gem to the Gemfile. Before installing it, open up the Gemfile, look for the line that starts with gem mysql, and check which version of the gem it's using. It may be an older version, so you can check the Ruby Gems directory for the newest version and use that instead if you like.

Run bundle install to install the mysql2 gem. If everything goes well, all you need to do is create the database (skip down to the "Create the database" section below). I ran into an error, which I'll discuss below.

Manually configure Rails for MySQL

To manually set up MySQL, first, remove the gem sqlite3 line from the Gemfile and add gem mysql2 in its place.

Configure the config/database.yml like below. These are just basic configurations provided by Rails (some comments cut out to save space), but adjust as needed:

# config/database.yml

# MySQL. Versions 5.5.8 and up are supported.
#
# Install the MySQL driver
#   gem install mysql2
#
# Ensure the MySQL gem is defined in your Gemfile
#   gem 'mysql2'
#
# And be sure to use new-style password hashing:
#   https://dev.mysql.com/doc/refman/5.7/en/password-hashing.html
#
default: &default
  adapter: mysql2
  encoding: utf8mb4
  pool: <%= ENV.fetch("RAILS_MAX_THREADS") { 5 } %>
  username: root
  password:
  socket: /tmp/mysql.sock

development:
  <<: *default
  database: myapp_development

# Warning: The database defined as "test" will be erased and
# re-generated from your development database when you run "rake".
# Do not set this db to the same as development or production.
test:
  <<: *default
  database: myapp_test

production:
  <<: *default
  database: myapp_production
  username: myapp
  password: <%= ENV['PACHISLO_DATABASE_PASSWORD'] %>

Error when installing the mysql2 gem

When trying to install the mysql gem, I got a crazy long error like this:

ERROR:  Error installing mysql2:
    ERROR: Failed to build gem native extension.

    current directory: /Users/morinoko/.rbenv/versions/2.6.3/lib/ruby/gems/2.6.0/gems/mysql2-0.5.2/ext/mysql2
/Users/morinoko/.rbenv/versions/2.6.3/bin/ruby -I /Users/morinoko/.rbenv/versions/2.6.3/lib/ruby/2.6.0 -r ./siteconf20190926-66829-1k4yip5.rb extconf.rb
checking for rb_absint_size()... yes
checking for rb_absint_singlebit_p()... yes
checking for rb_wait_for_single_fd()... yes
-----
Using mysql_config at /usr/local/bin/mysql_config
-----
checking for mysql.h... yes
checking for errmsg.h... yes
checking for SSL_MODE_DISABLED in mysql.h... yes
checking for SSL_MODE_PREFERRED in mysql.h... yes
checking for SSL_MODE_REQUIRED in mysql.h... yes
checking for SSL_MODE_VERIFY_CA in mysql.h... yes
checking for SSL_MODE_VERIFY_IDENTITY in mysql.h... yes
checking for MYSQL.net.vio in mysql.h... yes
checking for MYSQL.net.pvio in mysql.h... no
checking for MYSQL_ENABLE_CLEARTEXT_PLUGIN in mysql.h... yes
checking for SERVER_QUERY_NO_GOOD_INDEX_USED in mysql.h... yes
checking for SERVER_QUERY_NO_INDEX_USED in mysql.h... yes
checking for SERVER_QUERY_WAS_SLOW in mysql.h... yes
checking for MYSQL_OPTION_MULTI_STATEMENTS_ON in mysql.h... yes
checking for MYSQL_OPTION_MULTI_STATEMENTS_OFF in mysql.h... yes
checking for my_bool in mysql.h... no
-----
Don't know how to set rpath on your system, if MySQL libraries are not in path mysql2 may not load
-----
-----
Setting libpath to /usr/local/Cellar/mysql/8.0.17_1/lib
-----
creating Makefile

current directory: /Users/morinoko/.rbenv/versions/2.6.3/lib/ruby/gems/2.6.0/gems/mysql2-0.5.2/ext/mysql2
make "DESTDIR=" clean

current directory: /Users/morinoko/.rbenv/versions/2.6.3/lib/ruby/gems/2.6.0/gems/mysql2-0.5.2/ext/mysql2
make "DESTDIR="
compiling client.c
compiling infile.c
compiling mysql2_ext.c
compiling result.c
compiling statement.c
linking shared-object mysql2/mysql2.bundle
ld: library not found for -lssl
clang: error: linker command failed with exit code 1 (use -v to see invocation)
make: *** [mysql2.bundle] Error 1

make failed, exit code 2

Gem files will remain installed in /Users/morinoko/.rbenv/versions/2.6.3/lib/ruby/gems/2.6.0/gems/mysql2-0.5.2 for inspection.
Results logged to /Users/morinoko/.rbenv/versions/2.6.3/lib/ruby/gems/2.6.0/extensions/x86_64-darwin-18/2.6.0-static/mysql2-0.5.2/gem_make.out

After some googling, it seems like this error sometimes shows up if you don't have command-line tools installed (or it got removed when upgrading the mac OS).

Try to install them with:

xcode-select --install

If it installs, that may have fixed your problem. Run bundle install again and it should work.

For me, however, I got a notice telling me that the command line tools were already installed:

xcode-select: error: command line tools are already installed, use "Software Update" to install updates

To fix this, run the installer with

sudo open /Library/Developer/CommandLineTools/Packages/macOS_SDK_headers_for_macOS_10.14.pkg

sudo installer -pkg /Library/Developer/CommandLineTools/Packages/macOS_SDK_headers_for_macOS_10.14.pkg -target /

(I used the first command)

It turns out that this headers package was not included (missing?) in the newest version of Xcode, so the above command allows you to install it manually.

Now try running bundle install again and hopefully it will work (if not, you'll have to keep googling)!

Create the database

You will have to create the database from scratch and re-run any migrations if you had some already.

First, since Rails overwrote the config/database.yml file, make sure you open it up and make any necessary changes like editing the database names.

When everything is configured correctly, create the database:

# Create the database
rails db:create

#=> Created database 'mydatabase_development'
#=> Created database 'mydatabase_pachislo_test'

# Run migrations
rails db:migrate

Now you should be able to boot up your application with rails server!

References

mysql2 Ruby Gems page
Article & video on the Rails 6's new rails db:system:change command
Ruby on Rails Guides: Configuring a MySQL or MariaDB Database
Japanese article on how to fix macOS-related problem

Adding Custom JavaScript in Rails 6

Felice Forby — Wed, 21 Aug 2019 09:38:53 +0000

In Rails 6, JavaScript assets are no longer included with the app/assets/ directory and instead have been moved into a separate directory app/javascript handled by Webpacker. That's great, but when I wanted to add some custom javascript of my own, there wasn't any clear documentation that described how it should be done.

After some experimentation and digging around on the internet, here are a couple of methods that seem to work. Note that I'm not a javascript expert by any means, so if there is a better way—or other ways that I'm missing—let me know in the comments!

Method 1: Create a custom directory and require it in `application.js`

If you look at application.js, the comment at the top suggests that you "place your actual application logic in a relevant structure within app/javascript and only use these pack files to reference that code so it'll be compiled."

// app/javascript/packs/application.js

// This file is automatically compiled by Webpack, along with any other files
// present in this directory. You're encouraged to place your actual application logic in
// a relevant structure within app/javascript and only use these pack files to reference
// that code so it'll be compiled.

require("@rails/ujs").start()
require("turbolinks").start()
require("@rails/activestorage").start()
require("channels")

You can set this up by adding a custom directory within the app/javascript/, e.g. custom/, and then require the files within in application.js.

For example, if you have a javascript file named home.js in the app/javascript/custom/ directory, you can get it to load with require():

// app/javascript/packs/application.js

// ...

require("@rails/ujs").start()
require("turbolinks").start()
require("@rails/activestorage").start()
require("channels")

require("custom/home")

Since it's required in application.js, the custom javascript will be compiled along with all the other javascript into a timestamped application.js file that looks something like application-a03d1868c0a3f825e53e.js.

This is loaded by the <%= javascript_pack_tag 'application', 'data-turbolinks-track': 'reload' %> tag in the app/views/layouts/application.html.erb, automatically created when you make a new Rails app.

For a cleaner look, you could also name the javascript file index.js and require it with a simple reference to the directory like require("custom") because require() looks for an index.js file when given a path to a directory (if there is no index.js, it will fail).

Method 2: Add custom JavaScipt within the `app/javascript/packs` directory

If for some reason you don't want to create another directory, you could opt to add custom javascript files within the app/javascript/packs directory. Then, require the files in application.js with require().

For example, if you have a file named custom.js in app/javascript/packs, require it like below and it will be compiled into the timestamped application.js file with all the other javascript:

// app/javascript/packs/application.js

require("@rails/ujs").start()
require("turbolinks").start()
require("@rails/activestorage").start()
require("channels")

require("packs/custom")

Method 3: Using `javascript_pack_tag` for separate JavaScript files (packs)

If you don't want your custom javascript to be compiled into the application.js with everything else, you can get Rails to compile it into a separate file, or "pack."

To do so, add a custom file within app/javascript/packs, e.g. custom.js, then use the javascript_pack_tag helper where the file is needed in the views like so: <%= javascript_pack_tag 'custom' %>

The custom javascript will be compiled separately from the rest of the javascript into a timestamped custom.js that looks something like this: custom-a03d1756c0a3f825e53e.js

Here's how it might look if you added the custom javascript just before the ending body tag in the layouts/views/application.html.erb:

# app/layouts/views/application.html.erb

<!DOCTYPE html>
<html>
  <head>
    <title>My App</title>
    <%= csrf_meta_tags %>
    <%= csp_meta_tag %>
    <%= stylesheet_link_tag 'application', media: 'all', 'data-turbolinks-track': 'reload' %>
    <%= javascript_pack_tag 'application', 'data-turbolinks-track': 'reload' %>
  </head>

  <body class="<%= controller_name %> <%= action_name %>">
    <%= render 'layouts/header' %>

    <%= yield %>

    <%= render 'layouts/footer' %>

    <%= javascript_pack_tag 'custom' %>
  </body>
</html>

Thanks for reading!

Dynamic method handling with #method_missing and #respond_to_missing? in Ruby and Rails

Felice Forby — Fri, 09 Aug 2019 06:21:55 +0000

I just finished reading "The Well-Grounded Rubyist" and finally learned about the mysterious #method_missing method.

#method_missing gets called whenever an object receives a method call that it doesn't know how to handle. Maybe it was never defined, misspelled, or for some reason, ruby can't find it on the object's method look-up path.

The cool thing is is that you can use #method_missing to catch certain methods that you want to dynamically handle. Here's an example borrowed from "The Well-Grounded Rubyist":

class Student
  def method_missing(method, *args)
    if method.to_s.start_with?("grade_for_")
      puts "You got an A in #{method.to_s.split("_").last.capitalize}!"
    else
      super
    end
  end
end

This code would allow you to dynamically any method like grade_for_english, grade_for_science, etc. called on Student objects without needing to explicitly define several similar methods for each subject.

The name of the method that was called is always provided as a symbol through the method argument, so you can use it accordingly within your redefined version. The *args parameter grabs up any of the arguments that were passed along. It can also take an optional block, but I won't get into that here.

Make sure you always include super at the end of the redefined #method_missing so that any methods that cannot actually be handled in the end get passed back to the original definition of #method_missing

Thinking about my personal projects, I realized that #method_missing would finally let me solve one of the problems that had been bugging me for a while, so I'll use that as a real-world albeit simple example to illustrate how I used #method_missing to refactor my code.

Background & Original Code

I have a basic web app for a farmer that sells organic vegetables as a boxed set, kind of like a CSA but on a one-time basis instead of a seasonal one. Anyway, the site is available in both English and Japanese so the data for objects needs to be stored in both languages. In this case, I have a class called VeggieBox that keeps track of the seasonal veggie boxes.

I set up the app so that it pulls out the data from the database depending on the page's locale (:en or :ja). This enables me to share a single view file between the languages instead of separate views for each language.

The VeggieBox class makes objects with a title and description. To handle the different languages, the attributes are stored as title_ja, title_en, description_ja, and description_en.

Let's create a sample box now:

@veggie_box = VeggieBox.new
@veggie_box.title_en = "Summer box"
@veggie_box.title_ja = "夏のボックス"
@veggie_box.description_en = "Tons of delicious summer veggies!!"
@veggie_box.description_ja = "美味しい夏野菜いっぱい！！"

Because the view file is shared, I had to figure out how to display the correct data depending on whether the user was looking at the English or the Japanese site. To do so, I originally created #localized_title and #localized_description that used #send to parse in the I18n locale and call the appropriate method:

# app/models/veggie_box.rb

class VeggieBox < ApplicationRecord
  # ... other methods

  def localized_title
    self.send("title_#{I18n.locale}")
  end

  def localized_description
    self.send("description_#{I18n.locale}")
  end
end

Depending on which page the user views, the locale is set to either en or ja. So, if the user is on the English page, @veggie_box.localized_title would be equivalent to saying @veggie_box.title_en and pulling out the correct text in the view is as simple as:

<div class="description">
  <h3><%= @veggie_box.localized_title %></h3>
  <p><%= @veggie_box.localized_description %></p>
</div>

It's a fairly simple solution, but not as flexible as it could be. What happens if I started adding more and more attributes to the VeggieBox class? I would have to add a new localize_*** instance method for every single attribute!

That's where #method_missing comes in to save the day.

Refactor 1

Instead of having to use methods that have localized_ attached to it, I decided to simplify it to the base attribute name so that I could just write @veggie_box.title or @veggie_box.description instead.

My first attempt to use #method_missing was something like this:

# app/models/veggie_box.rb

class VeggieBox < ApplicationRecord
  # ... other methods

  def method_missing(method, *args)
    if method == "description" || "title"
      localized_method = "#{method}_#{I18n.locale}"
      self.send(localized_method)
    else
      super
    end
  end
end

If the app were to encounter something like @veggie_box.title, it wouldn't immediately know what to do because the VeggieBox object is calling a method that isn't explicitly defined; in this case title. It gets redirected to the #method_missing method defined in the VeggieBox class, which catches the unknown method title in the if-clause if method == "description" || "title". Instead of throwing a NoMethodError, the call to title gets processed into title_en if the user was looking at the English page, or title_ja if it was the Japanese page.

We can try it out in the console:

I18n.locale = :en
@veggie_box.title
 => "Summer box"

I18n.locale = :ja
@veggie_box.title
 => "夏のボックス"

Slightly better, but the method names are still hard-coded into the if-clause!

My next refactor will get rid of the hard-coding in the #method-missing definition.

Refactor 2

To get rid of the hard-coded values, I decided to transform the method name into the localized attribute method (e.g. title_ja) by adding on the locale and then simply checking whether or not the veggie box object responds to that method. If so, the localized method is called on the object with send. If not, it gets sent to super.

Here is the refactored code:

def method_missing(method, *args)
  localized_method = "#{method}_#{I18n.locale}"

  if self.respond_to?(localized_method)
    self.send(localized_method)
  else
    super
  end
end

Now, if another locale-based attribute were to be added to the VeggieBox class, #method_missing will be able to handle it without editing the code.

There is one slight problem that comes up when using #method_missing though, which I'll solve in the final refactor.

Refactor 3

Although #method_missing will let your objects properly handle certain method calls dynamically, it doesn't allow them act like "real methods". That means ruby won't recognize them in other places, for example, when you use object.respond_to?:

@veggie_box.respond_to?(:title)
 => false

@veggie_box.respond_to?(:description)
 => false

respond_to? returns false for the methods handled by #method_missing! Well, that's not right because it technically does respond to these methods even though they aren't defined.

Things like object.method, which let you turn methods into objects, won't work either:

@veggie_box.method(:title)
=> NameError (undefined method `title' for class `#<Class:0x00007fc56289b2a8>')

I realized this after checking the Ruby Style Guide's section on metaprogramming and this great article. They recommended also defining #respond_to_missing? when using #method_missing, which allows ruby to properly recognize that your objects do indeed respond to the meta-programmed methods. (Actually, the Ruby Style Guide recommends not using #method_missing at all... oops).

Here's how I defined #respond_to_missing? in my case:

def respond_to_missing?(method, *)
  localized_method = "#{method}_#{I18n.locale}"
  attribute_names.include?(localized_method) || super
end

Here, I used Rails' ActiveRecord method #attribute_names to make sure the attributes were registered to the class. If so, it passes the respond_to test.

Each object would now return true when asked if they respond to #title or #description.

@veggie_box.respond_to?(:title)
=> true

@veggie_box.respond_to?(:description)
=> true

The methods can now also be objectified:

method = @veggie_box.method(:title)

I18n.locale = :en
method.call
 => "Summer box"

I18n.locale = :ja
method.call
 => "夏のボックス"

Tests for Confidence

Considering this was the first time I used #method_missing, I wasn't 100% confident that the code would work correctly, so I added a test in the test suite (MiniTest) for the meta-programmed methods to give myself more confidence. Even if you are 100% confident, it would be a good idea to have a test anyway :)

The assert_respond_to tests make sure that instances of veggie boxes actually respond to the meta-programmed methods. The subsequent assert_equal tests first set the locale to :en or :ja and make sure the meta-programmed methods return the same values as the original attribute methods.

require 'test_helper'

class VeggieBoxTest < ActiveSupport::TestCase

  def setup
    # sets up a test object from a fixture file
    @veggie_box = veggie_boxes(:box_one)
  end

  # ...other tests...

  test "should respond correctly to localized methods" do
    # Make sure it actually responds to the meta-programmed methods
    assert_respond_to @veggie_box, :title
    assert_respond_to @veggie_box, :description

    # Make sure the method gets the correct values for each locale by 
    # comparing to the original attributes
    I18n.locale = :ja
    assert_equal @veggie_box.title_ja, @box.title
    assert_equal @veggie_box.description_ja, @box.description

    I18n.locale = :en
    assert_equal @veggie_box.title_en, @box.title
    assert_equal @veggie_box.description_en, @box.description
  end
end

Hope you enjoyed the article and if you haven't used #method_missing before, hopefully this will help!

References

"The Well-Grounded Rubyist" by David A. Black and Joseph Leo III
Ruby Style Guide
Method_missing, Politely blog article
Ruby Documentation on method_missing (English)
Ruby Documentation on method_missing (Japanese - has a nice code example even if you can't read the explanation)

Useful Git Commands For Removing Accidentally Pushed or Committed Files

Felice Forby — Mon, 22 Jul 2019 05:05:46 +0000

I find myself needing to reset commits often because I committed a file I didn't want to or forgot to add something to a commit. Every once in a while, I also need to remove the file from the remote repository (but not locally) because I accidentally pushed it. I always forget the commands, so here they are for everyone's reference :)

Remove a file you already pushed to the git repository

You can use the following command to delete a file from your git repo, for example, if you accidentally pushed it up or if you just don’t want it there any anymore.

git rm --cached name_of_file

This will not delete it locally, so it is safe on your computer if you want to keep it in there for reference without sharing on Git. To prevent it from being pushed to Git again, just add the file to your .gitignore.

Of course, if you just don’t need the file any more at all, simply delete it from your system as well.

BUT! If the file had sensitive data like passwords or secret keys, then you need to do a little bit more because the commits can still be found in the repository's history.

If the pushed file has sensitive data like passwords

As noted by Ölbaum's comment below (thanks!), the above method will not completely remove the file from the commit history.

To remove the sensitive file from your history as well, you can use an open-source tool called the BFG Repo-Cleaner or use git's git filter-branch.

BFG Repo-Cleaner apparently makes it much easier and faster to get the job done compared to filter-branch. It allows you to delete files or, alternatively, replace the passwords or keys within the file with the text ***REMOVED***. You can also remove huge files that you accidently pushed.

I haven't used BFG myself, but check out BFG Repo-Cleaner's documentation and download page to see how to use it. The instructions are pretty strait forward.

To learn about the git filter-branch, check out git's Using filter-branch article on their help site and the git filter-branch documentation.

Remove a file you accidentally committed in your last commit (but haven’t pushed yet)

I have a habit of committing everything with git add . so sometimes I accidentally add files that I actually want to have in a separate commit.

To remove certain files from a commit that hasn’t been pushed yet, first, undo the last commit with:

git reset --soft HEAD^1

Next, run:

git rm --cached <file-name>

to remove the file you don’t want to commit. This removes it from the commit and sets it back to an untracked file. You should be able to confirm by doing a quick git status.

Now you can commit the other files as usual by running:

git commit -m "my commit message"

The removed file or files can then be added into a separate commit!

Handy Git Shortcuts (Aliases) and How to Set Them Up

Felice Forby — Mon, 08 Jul 2019 02:55:44 +0000

If you’re using git, these handy short codes will speed up your workflow. The following are the basic abbreviated git commands that are recommended on the git website. I'm always forgetting how to do this when I need to set up git on new computer so posting this as a reference.

co for checkout
br for branch
ci for commit
st for status

How to Set Up

To set up an alias, you use the git config command with the --global tag so that it applies to all of your git repositories.

$ git config --global alias.<YOUR CHOSEN SHORTCUT> <THE ORIGINAL GIT COMMAND>

So to set up the basic shortcuts I mentioned above, open your terminal and put in the following:

git config --global alias.co checkout
git config --global alias.br branch
git config --global alias.ci commit
git config --global alias.st status

Now your all set to go! You can use co in place of checkout and so on. For example, for git commit, you can now do something like this:

git ci -m "add CSS styles"

See the official git documentation here.

Forem: Felice Forby

Database Video Notes

SQL Basics (M04 L01)

The Basic SELECT (M04 L02)

DATES, Order By, NULLS (M04 L03)

Group Functions (M04 L04)

SQL Subqueries (M05 L01)

SQL JOINs (M05 L02)

The Cartesian Product (M05 L03)

More SQL JOINs (M05 L04)

SQL Outer Join (M05 L05)

Left outer join

Right outer join

Note on UNION

Execution Plans

SQL DDL - CREATE (M06 L01)

Create

DROP

SQL DDL - ALTER (M06 L02)

DML - Insert, Update, Delete (M06 L03)

Insert

Update

TRUNCATE

DROP

DELETE

SQL Constraints (M07 L01)

Primary key constraint

UNIQUE

CHECK

FOREIGN KEY

SQL Triggers (MO7 L02)

Row level trigger vs. statement level trigger

Special features

SQL Case and View (MO7 L03)

CASE

Views

Auto-increment and UNION (MO7 L04)

Auto-increment

UNION

Understanding Rails Polymorphic Associations: A Case Study

The situation

The polymorphic association and database table

Creating the polymorphic association

Creating a migration to set up the polymorphic association

Something to think about: Polymorphism is not the only way to do this

When would you NOT want to use polymorphism

The final outcome

References

Linux Command Line Notes

Show current working directory

See username

Changing directories

Print to screen

Creating directories and file

Appending to a file

View directory contents

Viewing files

Using Wildcards * and ?

Moving and renaming files and directories

Copying file

Removing (Deleting) files and directories

Word and line counts

Sort command

Piping

man: See documentation on a command

Run a command as the super user

Sidekiq's sidekiq_retries_exhausted hook

References

Rename a Rails app (including database, Github, and Heroku names)

Rename the Github repository

Rename the app on Heroku

Rename the Rails databases

Development/Test database configuration

Situation 1: You have a db/seeds.rb file for all your data

Situation 2: You don't have seed data, but don't care if everything is erased

Situation 3: You don't have seed data, but you want to make sure no data gets erased.

Using a database dump (backup) file

Create the database dump file

Drop the current database

Rename and recreate the database

`man`: See documentation on a command

Situation 1: You have a `db/seeds.rb` file for all your data

Method 1: Create a custom directory and require it in `application.js`

Method 2: Add custom JavaScipt within the `app/javascript/packs` directory

Method 3: Using `javascript_pack_tag` for separate JavaScript files (packs)