Forem: Brandon Moreno

Rails Generator Cheat Sheet

Brandon Moreno — Tue, 13 Dec 2022 23:27:33 +0000

In this article is for newer developers looking to learn strategy and commands on Rails. When I started to learn ruby on rails; I kept going back and looking up how to use certain generators.

Rails is a web application development framework written in the Ruby programming language and was designed to make programming web applications easier. It allows you to write less code while accomplishing more than any frameworks.

First, install the Rails gem if you haven't done so.

gem install rails

"rails generate" is the same as "rails g"

Rails Generate

rails g

Running this command outputs all of the available generators.

- application_record
- assets
- benchmark
- channel
- controller
- generator
- helper
- integration_test
- jbuilder
- job
- mailbox
- migration
- model
- resource
- scaffold
- scaffold_controller
- system_test
- task

Models

rails g model

"rails g model NameOfYourModel field1:data_type field2:date_type"
A model is a Ruby class that is used to represent data and can interact with application's database through a feature of Rails called Active Record. It creates both the model and the migration.

Model names are singular, because an instantiated model represents a single data record.

The generator adds timestamps by default(created_at and updated_at). Also the default type of an attribute is string so you don't have to include it. If I put name in field; it will be treated as name:string.

A generator will include the :password_digest field in the migration and the has_secure_password method in the model; if you include password:digest when generating a model.

Another neat thing rails does for us is when adding reference to a field generates an id column, which does a belongs_to associations for us.

# generates the Product migration with a foreign id for Seller

rails g model Product name description:text seller:references

It will create a migration that looks like this

class CreateProducts < ActiveRecord::Migration
  def change
    create_table :products do |t|
      t.string :name
      t.text :description
      t.references :seller, null: false, foreign_key: true

      t.timestamps
    end
  end

# and the Seller model, with the association

class Product < ApplicationRecord
  belongs_to :seller
end

When making any adjustments you need to run rails db:migrate after the changes.

Migrations

A Rails migration is a tool for changing and modifying an application's database schema.
Migration Data Types


:primary_key - translates into whatever the primary key datatype your database of choice requires

:string - use for short strings such as names and emails

:text - use for long strings, normally captured by textarea

:integer - it’s a whole number, eg. 0,12,12532

:float - decimal numbers stored with fixed floating point precision

:decimal - stored precision varies; good for exact math calculations

:datetime - both date and time

:timestamp - same as datetime; usually used for created_at/updated_at

:time - hours, minutes, seconds

:date - year, month, day

:binary - store images, videos and other files in their original format in chunks of data called blobs

:blob - similar to binary, contains the metadata about a file. Blobs are intended to be immutable

:boolean - self explanatory - true/false

:json - from Rails 5 onwards, you can natively store JSON values thanks to this Pull Request. A lot of people still use Postgres’ jsonb datatype though.

Active Record provides methods that perform common data definition tasks


- add_column
- add_index 
- change_column
- change_table
- create_table
- drop_table
- remove_column
- remove_index
- rename_column

If the migration name is of the form AddXToY or RemoveXFromY and is followed by a list of column names and types then a migration containing the appropriate add_column and remove_column statements will be created.

rails g migration AddPriceToProduct price:integer

# generates the following migration

class AddPriceToProduct < ActiveRecord::Migration[6.1]
  def change
    add_column :products, :price, :integer
  end
end

Controller

rails g controller

"rails g controller NameOfController action1 action2 ..."

Action Controller is the C in MVC. The controller is responsible for making sense of the request and producing the appropriate output which, does most of the groundwork for you. You can think of the controller being the middleman between models and views. It makes the model data available to the view, so it can display that data to the user and saves/updates user data to the model.

The naming convention of controllers in Rails favors pluralization of the last work in the controller's name, although it is not strictly required.

# generates a controller and actions...

rails g controller Products index show update destroy

class ProductsController < ApplicationController
  def index
  end
  def show
  end

  def update
  end
  def destroy
  end
ene 

# and routes in the routes.rb file

Rails.application.routes.draw do
  get ‘products/index’
  get ‘products/show’
  get ‘products/new’
  get ‘products/edit’
end

A good to know, to generate just the controller file, without all the extra files and folders use the following:

rails generate controller ControllerName index show new edit --no-helper 
--no-assets --no-test-framework --skip-routes --skip

Resource

$ rails g resource --no-test-framework

# --no-test-framework will not install the test files

"rails g resource NameOfResource field:data_type field:data_type"

Each of the previous generators, resource does it in one command. It will create a model, does the migration, have an empty controller(for your actions), and have full CRUD routes in your routes.rb

rails g resource Product name description:text price:integer 
--no-test-framework

invoke  active_record
      create    db/migrate/20200326023754_create_products.rb
      create    app/models/product.rb
      invoke  controller
      create    app/controllers/products_controller.rb
      invoke    erb
      create      app/views/products
      invoke    helper
      create      app/helpers/products_helper.rb
      invoke    assets
      invoke      scss
      create        app/assets/stylesheets/products.scss
      invoke  resource_route
       route    resources :products

This will create the following:

# creates a migration...
in db/migrate/20190714193807_products.rb

class CreateProducts < ActiveRecord::Migration[6.1]
  def change
    create_table :products do |t|
      t.string :name
      t.string :capital
      t.timestamps
    end
  end 
end
# a model...
class CreateProducts < ActiveRecord::Migration
  def change
    create_table :products do |t|
      t.string :name
      t.text :description
      t.integer :price

      t.timestamps
    end
  end
# a controller...
class TerritoriesController < ApplicationController
end

#config/routes.rb
Rails.application.routes.draw do
  resources :products
end

As you can see this tool saves you time when you're doing a code challenge or want to do all the action in one command.

Scaffold would set up everything for you as well just as, routes, controller, views, models, and migrations.
rails g scaffold

More Info

# Run migration
$ rails db:migrate

# Rollback last migration
$ rails db:rollback

# Run database seed code
$ rails db:seed

# Delete and re-create db and run migrations
$ rails db:reset

Routes


# Route maps to controller#action
get 'welcome', to: 'products#home'

# Root page (root_path name helper)
root 'products#home' 

# Named route 
get 'exit', to: 'sessions#destroy', as: :logout

# Create all the routes for a RESTful resource
resources :items

HTTP Verb Path

# HTTP    Verb Path    Controller#Action  Named Helper
# GET     /items           items#index    items_path
# GET     /items/new       items#new      new_item_path
# POST    /items           items#create   items_path
# GET     /items/:id       items#show     item_path(:id)
# GET     /items/:id/edit  items#edit     edit_item_path(:id)
# PUT     /items/:id       items#update   item_path(:id)
# DELETE  /items/:id       items#destroy  item_path(:id)

# Only for certain actions
resources :items, only: :index

# Resource with exceptions 
resources :items, except: [:new, :create]

# Nested resources
resources :items do
  resources :reviews
end

# Dynamic segment: params['id']
get 'products/:id', to: 'products#show'
# Query String: url /products/1?user_id=2
# params will be {'id' 'user_id'}

Model Validation examples

# Model validation
validates :title, :description, :image_url, presence: true
validates :email, presence: true, format: { with: /\A[^@\s]+@[^@\s]+\z/, message: 'Must be a valid email address'}
validates :price, numericality: { greater_than_equal_to: 0.01 }
validates :title, uniqueness:  true
validates :title, length: { minimum: 3, maximum: 100 }
validates :type, inclusion: types.keys

# Model relationship
belongs_to :customer

# Relation with cascade delete
has_many :invoices, dependent: :destroy

#One to one
has_one :profile

# Hook methods 
before_destroy :ensure_not_reference_by_any_invoices 
before_save :downcase_email

Active Record

# Active record common methods
Article.all
# Throw error if not found
Article.find(params[:id])
# Do not throw error if not found
Article.find_by(product_id: product_id)
@category = Category.find_by!(slug: params['slug']) # Return Not Found Error (404 page in production)
Article.group(:product_id).sum(:quantity)
Article.where('quantity > 1')
Article.where(cat_id: cat_id, model: model)
Article.where(model: model).or(Article.where(cat_id: cat_id))
Article.join(:categories).where(categories: { id: 2 } )
Article.where("title LIKE ?", "%" + params[:q] + "%")
Article.count
Article.first
Article.last
Article.column_names # ['id', 'name', 'price']
Category.delete_all # delete all rows in Category table
product.category = Category.all.sample # random for Faker data
@products = Product.offset(5).limit(10).all # skip 5, take 10

# Create flash (reset every new request)
flash[:success] = 'User created with success!'

# Create flash.now (reset every new view render)
flash.now[:error] = 'Please select s user!'

# Create session (reset every browser close)
session[:user_id] = user.id

# Check if session exist
session[:user_id].nil?

# Remove
session.delete(:user_id)

# Remove all
reset_session      

# Create cookie (reset at expiration date)
cookies.permanent[:remember_token] = remember_token

# Encrypted cookie
cookies.permanent.encrypted[:user_id] = user.id

# Delete cookie
cookies.delete(:user_id)

Deployment with Heroku

# Create git and push to Heroku
$ heroku create
$ git remote
$ bundle install --without production
$ git status
$ git add -A
$ git commit -m 'heroku deployment'
$ git push origin master
$ git push heroku master
$ heroku run rails db:migrate
$ heroku run rails db:seed

# launch the upload site
$ heroku open

Rails CLI

# Create a new rails app
$ rails new project_name 

# Start the Rails server
$ rails s

# Rails console
$ rails c

# Install dependencies
$ bundle install

# View all routes
$ rails routes

Files

--no-test-framework — prevents generator from creating standard tests

--skip — skips files that already exist

--no-assets — prevents generator from creating assets

--no-helper — prevents generator from creating helper

--skip-routes — prevents generator from adding routes to routes.rb

I hope you can take some info and apply into your code. Thank you for reading and best wishes.

Cheat Sheet For Ruby

Brandon Moreno — Mon, 21 Nov 2022 05:26:04 +0000

Ruby is...

A dynamic object-oriented, general-purpose programming language with a focus on simplicity, just as every programming language was originally designed to solve some kind of problem. It was designed and developed in the mid-1990s by Yukihiro "Matz" Matsumoto in Japan. Matsumoto, often referred to as "Matz", first developed the idea for Ruby in the early 1990s.
With Ruby you can build different kinds of programs(Games, Command line interfaces, Web servers, and Server-side applications)

In this Article, we'll go over some commands that will help on your journey of learning ruby.

Basics

&&: and
||: or
!: not
(x && (y || w)) && z: use parenthesis to combine arguments

Commenting

# this line is commented out

IRB

$ irb
#To be able to write ruby in your terminal

Blocks and Procs
Depending on preference you can replace {} with do end and vice versa. Keep in mind, this will not work for hashes and #{} escaping.
Blocks are not objects so, just is a bit code between do, end, or {}. This can be passed to methods like .each, .select, and .find

Snake_Case
Rudy uses Snake Case.

Hello_World

or 10_000_00: 1000000.

Class
@: instance variable
@: class variable

Constant
Constants are used for values that aren't supposed to change and MOSTLY are all caps. Example:

FRUIT = "banana"

Arrays

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

If you see << it's just like a push method in JavaScript. [1,2,3] << 4 # [1,2,3,4]

Numbers
When using integer it doesn't place decimals, but to put a number with decimals use float.

CRUD
When you see CRUD it means create, read, update delete methods.

Booleans
At the end of a name if there is a question mark, it's a boolean. Example: empty?, all?, or match?

Hashes

hash = { "key1" => "value1", "key2" => "value2" } # same as objects in JavaScript

hash = { key1: "value1", key2: "value2" } # the same hash using symbols instead of strings

Symbols
:symbol symbol is like an ID in html. :symbol != "symbol". Symbols are often used as Hash keys or referencing method names.

my_hash = { key: "value", key2: "value" } # is equal to { :key => "value", :key2 => "value" }

Methods

def say_hello(hello, *names) # *names is a split argument, takes several parameters passed in an array 
  return "#{hello}, #{names}"
end

start = say_hello("Steve", "Sam", "Maz", "
Dan The Man") # call a method by name

def name(variable=default)
  ### The last line in here gets returned by default
end

.times

47.times do
  print “this text will appear 47 times”
end

.map() # is the same as .collect

Classes

class Person # class names are rather written in PascalCase (It is similar to camelCase, but the first letter is capitalized)
  @@count = 0
  attr_reader :name # make it readable
  attr_writer :name # make it writable
  attr_accessor :name # makes it readable and writable

  def Methodname(parameter)
    @classVariable = parameter
    @@count += 1
  end

  def self.show_classVariable
    @classVariable
  end

  def Person.get_counts # is a class method
    return @@count
  end

  private

  def private_method; end # Private methods go here
end

the_boy_maz = Person.new("Mazin")
the_boy_maz.show_name # Mazin

if 1 < 2
puts “one smaller than two”
elsif 1 > 2 # *careful not to mistake with else if. In ruby you write elsif*
puts “elsif”
else
puts “false”
end

String Method

"Hello".length # 5
"Hello".reverse # “olleH”
"Hello".upcase # “HELLO”
"Hello".downcase # “hello”
"hello".capitalize # “Hello”

Rake

rake db:create                          # Creates the database from DATABASE_URL or config/database.yml for the current RAILS_ENV (use db:create:all to create all databa...
rake db:drop                            # Drops the database from DATABASE_URL or config/database.yml for the current RAILS_ENV (use db:drop:all to drop all databases in...
rake db:fixtures:load                   # Load fixtures into the current environment's database
rake db:migrate                         # Migrate the database (options: VERSION=x, VERBOSE=false, SCOPE=blog)
rake db:migrate:status                  # Display status of migrations
rake db:rollback                        # Rolls the schema back to the previous version (specify steps w/ STEP=n)
rake db:schema:cache:clear              # Clear a db/schema_cache.dump file
rake db:schema:cache:dump               # Create a db/schema_cache.dump file
rake db:schema:dump                     # Create a db/schema.rb file that is portable against any DB supported by AR
rake db:schema:load                     # Load a schema.rb file into the database
rake db:seed                            # Load the seed data from db/seeds.rb

Side Note
sudo lsof -i :<port> sudo kill -9 <port PID>
Kill a open port in OSX.

Thank you for taking the time to go over this article. Wish the best for you on your ruby journey.

Concepts About React

Brandon Moreno — Sat, 05 Nov 2022 06:29:50 +0000

Over recent years, React has been a popular library used to develop front-end applications. Instagram, Khan Academy, and Netflix are built with React.js, so React.js is one skill used commonly. Coming from JavaScript and learning React.js, here are some concepts you need to know to have a better experience creating a React App.

What is React?

React.js is an open-source JavaScript library created by a software engineer at Facebook and was first developed on Facebook’s News Feed. As for the front end (what the user sees on a site), React.js targets parts of the website into components. You can think of components as small building blocks that make up the website.

Components & Props

As known components let you split the UI into independent and reusable code. Components play a big part in React.js having the functionality and the presentation. No matter what components do in your application the goal is always the same. It must contain some sort of code that describes what it should do and display it to the DOM. To distinguish a component, those names that start with a capital letter are components.

function App () { 
  return (
    <>
       <Article />
    </>
  )
}

Here we have a parent Article component. The Article component has information about an interesting topic.

(Having issues with dev not displaying my diagram of showing the tree files)

The image shown above shows the hierarchy of components. The Article component is a parent component while the MysteryTopic component is a child component. In React.js components files look like this:
https://ph-files.imgix.net/2129752d-63f7-4e5b-96f5-4c3697a0ca52.png?auto=format&fit=crop

Props

Props are an important mechanism for passing and accessing information/data between React.js components. Props are also known as properties, which refer to the “props” of an object. At first glance, props can be a little tricky in how they behave. Passing information as props goes in a one-directional flow(down) and data that has been passed down, cannot be changed. Props can be sent up to their parent components but are not recommended at first, and that is another discussion in the future.
Usually, you would think that creates a limitation to using props but, it's good because it provides a layer of protection to performance and security in your React code.

function Welcome(props) {
  return <h1>Hello, {props.name}</h1>;
}

Here we're passing some information as "props" and targeting the props(information) names.

States

A state is also an object which can contain as many properties as needed. The state holds information that is dynamic which changes the output of the render or changes over time when the user interacts with the application. This gives us a way to maintain and update information within our React.js components.

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

  function increment() {
      setCount(count + 1);
      }
return <button onClick={increment}>{count}</button>;

Here we have a single component that is rendering an integer to our React App. As the user each time it clicks on the button, it should increment the integer by 1. The useState is holding our current value integer to 0. We represent the integer value in the component using state and updating when it's clicked adding 1 each time.

Hooks

As in Rect 16.8 version Hooks were introduced as a new feature. What are hooks? A hook is a feature that uses state and other React features in functional components without writing class. In other other words, it allows function components to have access to states just as shown in the previous code. Just make sure to use import Hooks from “react”. The rules to use hooks are, to only be called inside React function components, called at the top level of a component, and cannot be conditional.

Thank you for taking the time to read! I hope you enjoyed and learned a lot about React. Reading is a part of learning but, the only way to master is to apply the practice.

Brief Intro to Array

Brandon Moreno — Tue, 11 Oct 2022 06:18:17 +0000

In JavaScript arrays plays a big part in listing items or having a list coming from an API(source). Arrays are a special type of object and can be a single variable that is used to store similar data or data from a common source. When a typeof operator is used for an array it returns “object”. Usually, arrays are best described as arrays in JavaScript.

let colors = ["blue", "red", "white" ] // LOG: typeof colors: ‘object’

In the example shown above, the items listed in a particular order, are surrounded by square brackets ([]) and separated by commas (,). In this case, the elements in the array are strings, but arrays can store any data type in JavaScript. The cool thing about arrays is the data type in the array remains the same and has the same properties as singular variables in JavaScript.

Accessing Array Elements

let favoriteFruits = ["watermelon", "mango", "strawberry", "banana"];

To be able to access the elements within the array JavaScript uses non-negative integers as indexes and is always zero-indexed. The first element of the array starts at 0, the second element is at 1, and the last element is always one less than the number of elements in the array.

// [0] = watermelon
// [1] = mango
// [2] = strawberry
// [3] = banana

If we want to access “strawberry”, we need to use the bracket notation. Also, the “length” property of an array is the number of elements in an array.

favoriteFruits[2]; // ‘strawberry’ favoriteFruits.length; // 4

To access the final element, we use the “.length-1” property. If an index does not exist in an array it will return as undefined.

favotiteFruits.length-1; // banana favoriteFruits[47]; // undefined

Now that we touch a bit about what are arrays, there are array iteration methods. Iteration methods operates every single element in an array like a loop. A loop is a program that executes a particular function over a number of times it's set to be. Let’s consider forEach method.

forEach()
arrayName.forEach(function, argument)

forEach() method uses dot notation to join the method to the array and takes in two parameters, which can be a callback function and an argument. A callback function is a First Class Function, which has the ability to use primitive types(boolean, strings, numbers) and is passed as an argument to another function. The second argument is an optional parameter.

let numbers = [5, 47, 24, 14, 100];

let numbersAddFive = numbers.forEach((element) => console.log(element + 5));

A friendly reminder arrow function (=>) with multiple parameters requires parentheses and with a simple expression, the return keyword is not needed. In this case, the console.log() acts as the return keyword and the forEach() method loops over the “numbers” array; while putting the (element + 5) function adding 5 to every element.

// 10
// 52
// 29
// 19
// 105

Yet, this does not return a new array, but an ordered list of the numbers array. In order to return a new array, we need to use an array method called .push(). The .push() method can add multiple elements to the end of an array and creates a new array.

let newSetOfNumbers = [];

numbers.forEach((element) => newSetOfNumbers.push(element + 5));

console.log(newSetOfNumbers); // LOG: [10, 52, 29, 19, 105];

I declared an empty array for newSetOfNumbers and used the .push() method to fill up the empty array from the callback function in the forEach() method. The forEach() method targets every element and performs newSetOfNumbers.push(element + 5), which outputs into the newSetOfNumbers while having the same order of the elements as in the numbers array. When newSetOfNumbers is console.log it returns an array.

I barely touch the topic of arrays and briefly went into array loops using forEach() method. I hope this article helped you add more information to your knowledge about arrays. Feel free to leave feedback because I just started on the journey to becoming a Software Engineer.

Citation

“Array - Javascript: MDN.” JavaScript | MDN, https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array.

JavaScript Array Iteration, https://www.w3schools.com/js/js_array_iteration.asp.

“Array.prototype.foreach() - Javascript: MDN.” JavaScript | MDN, https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/forEach.