Limit a method’s access in Ruby

To¬†limit a method’s access¬†we use 3 methods: private, protected and public.
Public: By default all methods defined are public. All instances of a class can use these public methods. Public methods are called with an explicit receiver.
Private methods are the ones defined under the private keyword and they can only be used within the class definition. The receiver in private methods is self. We use private methods for internal usage without a receiver.
Protected methods are similar to private with addition that it can be called with or without an explicit receiver but that receiver is always self or an object that inherit from self. We use protected methods defined as self.my_method for internal usage in other classes whenever inheritance isn’t used.

Different ways to invoke a method in Ruby

  1. (Single run time) Using dot notation and calling the method on the object:
  2. (Persist name of method to database) Using send method:
  3. Get the method and call it like a Proc:
  4. Not good practice but useful sometimes. (Self-modifying method code):

Differences between class, object and module in Ruby

Ruby is a class-based object-oriented programming language. Meaning that every object is an instance of a class, and a class defines the state (variables) and behaviours (methods) of an object. An object is an entity with state and behaviour, as defined by its class.

Object is an instance of a class which allows you to use the classes attributes and methods. Object is the default root of all Ruby objects. Everything in Ruby is an object, including classes. An object in code is a thing with all the data and all the logic required to complete a task. Objects are models and metaphors for the problems we solve in code. Ruby comes with a few types of Objects to get us started, things like Integer, String, Array, etc. We call these base types of Objects “Primitives.” But what if we wanted to create a new type in our programming universe, a new kind of object for our code? That’s what the class keyword and object orientation allows us to do.
Class is a type of structure of information and code. A Ruby class is an object of class Class, which contains all the object things plus a list of methods and a reference to a superclass. A class is the blueprint from which individual objects are created.
A module is a collection of methods and constants. They hold methods, like classes but they can’ t be instantiated. It is not possible to create objects from a module. Modules are useful when we have methods that want to reuse in certain classes

Rails Portfolio Project – Recipe Manager

Recipe Manager was built using Ruby on Rails framework and Bootstrap. All users can safely signup, login and logout. I created authentication and authorization methods without using any gem. Recipe Manager include a third party signup/login via Github thanks to the OmniAuth gem.

Users can check the recipes, rate and comment them but only admin users can create and edit the recipes and the categories. The user can browse recipes by name and author and all the comments by author and recipe. The app include reasonable validations for its forms and an ActiveRecord scope method to get the newest recipe that can be seen in its own URL, in this case: http://localhost:3000/newest_recipe.

My models:


  • Has many recipes
  • Has many comments
  • Has many ratings
  • Attributes: name, email, password_digest, admin, and finally I added uid and provider for the signup/login with OmniAuth.


  • Belongs to a user
  • Has many recipe_ingredients
  • Has many ingredients through recipe_ingredients
  • Has many recipe_categories
  • Has many categories through recipe_categories
  • Has many comments
  • Has many ratings
  • Attributes: name, cooking_time, servings, directions, date created


  • Has many recipe_ingredients
  • Has many recipes through recipe_ingredients
  • Attributes: name


  • Belongs to recipe
  • Belongs to ingredient
  • Attributes: quantity.


  • Has many recipe_categories
  • Has many recipes through recipe_categories
  • Attributes: name


  • Belongs to Recipe
  • Belongs to Category


  • Belongs to user
  • Belongs to recipe
  • Attributes: content


  • Belongs to user
  • Belongs to recipe
  • Attributes: score

Generate my new application:

Generate my models with their associations and create my db:

*Adding :default => true to boolean in existing Rails column

Implementing a sign-in, login and logout functionality:

In order to encrypt the passwords I will use the gem bcrypt, include “has_secure_password” in my User model and have a password_digest attribute in my users table.

Sign in with Github

  • Add to your gemfile the OmniAuth gem and the provider-specific OmniAuth gem, in this case “omniauth-github”, and run bundle install.
  • Create a file named config/initializers/omniauth.rb. I will contain the following:
  • Create an application in Github.

[Settings/Developer Settings/OAuth Apps/Register a new OAuth application]

In homepage url enter: https://localhost:3000/

In the Authorization url: http://localhost:3000/auth/github/callback

After creating the app you get a client ID and a Client secret.

  • Add dotenv-rails to your Gemfile and run bundle install.
  • Create a file named .env at the root of the application and add your Github credentials.

  • Add .env to your .gitignore file.
  • Create a link to login via Github
  • The User model needs these attributes, all strings: name, email and uid, that it is the user’s ID on Github. *I added a provider attribute later on.
  • Create the route where Github will redirect users in the callback phase of the login process.
  • And in our Sessions controller we find or create the user who logging via github.
  • In our User model:

I want to add some helpful links:

Sinatra Portfolio Project

I would like to make a Content Management System for my daughter’s nursery. They keep the daily information about the children in notebooks full of very easy to lose post its and hope this app can help with it. The daily information will be referred to as activities.

The app provides a database and web interface for users to:
* Sign up, log in or log out securely as a nursery staff or parent.
* Nursery staff can create, read, update, and delete (CRUD) an activity.
* Parents can read only the personal profile page of their children.
* User inputs are validated.
I am using Sinatra to build the app, extended with Rake for working with a SQL database using ActiveRecord ORM.
Sinatra is a Domain Specific Language implemented in Ruby that’s used for writing web applications.
My first steps to create the app are:

-Create a repository in Github.

-The project structure following the MVC conventions.

-Set my environment and my I am following the Modular Sinatra Pattern and having a¬†¬†file is one convention of it. The purpose of is to detail to Rack (Sinatra gem is built on top of Rack) the environment requirements of the application and start the application, mount my application controllers. Rack is a convention, or specification, that lets web applications “plug” into a common interface for handling HTTP requests. To actually serve requests, we need a¬†web server¬†‚ÄĒ something that can translate HTTP requests into Ruby calls. My gem ‘thin’ is a web server that do this job.

-Create my Gemfile with all gems that I am going to run trough Bundle, which is set up in my environment file.

Here are the gems I want to use:

Sinatra: to create my web application.
activerecord: it is my Object Relation Mapper, links my Ruby models with rows in my database table. It is a gem to have access to the database mapping and associations.

sinatra-activerecord: it gives me access to some Rake tasks.
rake: short for “ruby make”, it is a package that lets me quickly create files and folders, and automate tasks such as database creation.
require_all: for a simplier way to load code.

sqlite3: sqlite is a library that implements a SQL database engine. sqlite is my database adapter gem.

thin: it is a web server.

shotgun: this is my development server.
pry: my debugger.
bcrypt: it is a hashing algorithm for passwords.
tux: it gives me an interactive console that pre-loads my database and
ActiveRecord Associations.
rake: great gem to create actions and tasks, for example a pry console to test the models and the database. It needs a Rakefile in the root directory of the app with the environment specified and requiring¬†‚Äėsinatra/activerecord/rake‚Äô.
Model classes

I think that I will need at least 3 models, User, Activity and Student.

1. User: stores user attributes, including:
* Username
* Email
* Password (Secured with Bcrypt hashing algorithm)
* Nursery_staff, a boolean value to indicate if a user is a nursery staff
2. Activity: stores activity attributes, including:
* Date
* User_id, to associate Activity to User
* Student_id, to associate Activity to Student
* Breakfast
* Morning Snacks
* Lunch
* Afternoon Snacks
* Sleep
* Nappies
* Comments
3. Student: stores student attributes, including:
* Name
* User_id, to associate Student to User
* Key person
* Room
Model Associations
User has many students and has many activities
Student has many activities and belongs to a User (parent).
Activity belongs to a Student and belongs to User.

Is it works?

I am using Visual Studio Code and after creating the structure of my project with very basic info I tried to run shotgun and was getting the following error:

I had a server running in the background. After trying a lot of different things I could stopped it with the following I found in StackOverflow:

Ran lsof -i :9393 (9393 is the port I ran it on).

I killed the process using kill -9 *pid*. My pid was: 58152.

When I ran lsof -i :9393 again, nothing showed up.

I then ran shotgun and everything works fine now.

Model Validations
You can find all info about validations here.
I will use in my controllers the methods save and update, which trigger validations for themselves and will save the object to the database only if the object is valid.
I will use some helpers to validate that some specified attributes are not empty. I want to make sure that a user gives an username and an email and that an activity has a date and a student has a name at least. I will validate the uniqueness of the email too.







Authentication system

Enable sessions in your AppController and use the gem¬†bcrypt.¬†Make sure¬†your user model¬†has_secure_password and that on your users table you store the password like password_digest“.





Protecting the session secret by Martin Fowler:

I changed my configuration to look like this:





The password fails safe to a secure hex value if SESSION_SECRET is unset.


Create a Database folder (db), run your migrations to create your tables. I have created one table for the students, another table for my users and a last one for the activities.

I run:

rake db:create_migration NAME=create_students

rake db:create_migration NAME=create_users

rake db:create_migration NAME=create_activities

Then modify my migration tables according to my needs.

And finally run rake db:migrate, and all your tables will be added.

Play with my models and the database.

I run tux in my console but I got the following error does not support require_relative so I changed my link and everything works fine!

Now it is time to be more creative and design my routes in the controllers and my views. I am using Bootstrap.

To check this project follow the link.

Programming my classes

After all the previous steps now I have pretty clear how I am going to structure my code.

I want a CLI that displays art exhibitions and gives to the user more info  about the one it chooses. I am going to scrape from a public website all the info concerning the art events (Artlyst).

I want three classes: a CLI, an exhibition one and a scraper.

This three classes will live inside a lib folder.

I finally changed the CLI class name for artify in case I want to publish my gem in So I have threes classes: artify, exhibition and scraper.

Let’s start coding!

To check my code go to my Github repository.

After programming my classes I require them inside the environment.rb file.

And that’s it!

If you want to play with this gem please check this link: readme page.

Hope it was helpful!

The executable file

I create a folder bin and create inside of this folder an executable file called in this case as the gem, ‘artify’.

When I type: $ruby bin/artify,¬† everything run but I don’t want this. I want that the user from the bash can type: $ ./bin/artify.

So I type:

$ cd bin/

$ ls -lah

Ad I can see that artify doesn’t have executable permissions. To change this I type:

$ chmod +x artify

$ ls -lah

This executable file is not a ruby file so I have to include at the top the following:

#!/usr/bin/env ruby

Then I require our environment file to use all the gems already installed.

In this file I want to run for my still imaginary CLI class. I want to write here something like:

So, at this point, I know I want a class CLI, where I am going to build all the methods and keep all data to run my CLI.

I finally changed this name for ‘artify’ in case I want to publish it in