Introduction

Capistrano is an automation tool for executing commands on the server through SSH. Capistrano basically a script which provides various commands to execute which helps to deploy the code on the server. It helps to reduce the manual efforts to deploy code and use the same command to deploy code every time. In this document, I am going to describe how to deploy your application from GitHub to the production server.

Capistrano Flow

The Capistrano have main flow as follows:

1. First, you need to install and configure Capistrano in your application.

2. Once the installation and configuration are done every time you have to push the latest code to GitHub and then run Capistrano script to deploy it to the server.

Step 1: Install the following gems in Gemfile.

gem 'capistrano', require: false

gem 'capistrano-rails', require: false

gem 'capistrano-rvm', require: false

gem 'capistrano-bundler'

Step 2: Run following commands to install these gems and initialize Capistrano

$ bundle install

$ bundle exec cap install

Step 3: Capfile

require 'We need to uncomment some lines according to our requirement. As I want to run bundle install automatically I have uncommented line capistrano/bundler'. In the same way for precompiling assets and running migration require 'capistrano/rails/assets' , require 'capistrano/rails/migrations'. As I am using RVM, I have uncommented the line require "capistrano/rvm". Similarly I am using GitHub for code deployment require "capistrano/scm/git"

, install_plugin Capistrano::SCM:: Git.

 Step 4: config/deploy.rb

deploy. In rb file mention name of the application. Then mention GitHub repository path as I have mentioned ‘git@github.com:username/application_name.git’.

Mention username and password of your GitHub repository. We also have to connect server where we have to deploy our application with GitHub. For that, we have to enter ssh public key in settings of GitHub so that it will connect GitHub with the server.

Step 5: config/deploy/production.rb

There are two ways to define servers. First one is with simple role-based syntax and another one is extended server based syntax. You should use only one from both, not both of them. In this, we have to set the environment of our rails application like ‘production’. Mention the branch of your code and also the path of application folder on the server in front of ‘deploy_to’.

(b) production.rb

Step 6: Run script

Now, run following command to run the script.

$ cap deploy production

Step 7: Server Setting

In this tutorial, we simply cloned our application code from GitHub to our server. While first time deployment of code it will use a defined directory structure on the server.

1. ‘release’ folder holds all deployments in a folder. Every time you run Capistrano to deploy code, it makes clones GitHub repository to a new subdirectory inside release.

2. ‘current’ folder is a symlink pointing to the latest release inside the releases folder. This symlink will update at every deployment. If deployment fails in any step the current symlink still points to the old release.

3. ‘repo’ folder holds the copy of GitHub repository.

4. ‘shared’ folder contains the configuration which will not be taken from the GitHub repository. As Capistrano deploy works by cloning the GitHub repository into a release It will contain files like (e.g. config/database.yml and config/secrets.yml). You have to put those files in shared and instruct Capistrano to symlink them to release directory on every deploy. This is done through the linked_files and linked_dirs configuration options in deploy.rb file.

Mention the path to the current folder in configuration settings of the server as it contains the latest code from GitHub repository and then restarts the server.I have mention the path like DocumentRoot /home/path/to/your_rails_app/current/public in /etc/apache2/sites-available/application_name.conf file.

  An Introduction to RabbitMQ:

 
RabbitMQ is a message broker software in Ruby on Rails framework where web applications connect to the queue and transfer a message onto it.

When one application server sends the request to another application server, RabbitMQ works as a queue manager where requests handled and served one by one. 

Message transferring is done from one application to another through RabbitMQ. RabbitMQ uses the standard Advanced Message Queuing Protocol (AMQP) to keep message request in queues and serve easily. The message may contain any information like simple text transfer or task that need to process on another server.

This RabbitMQ software saves messages in a queue and keeps in a queue until receiving application get connected and start processing the messages.

Why should we use RabbitMQ in Ruby on Rails Development?

Message broker works on the producer, broker, and consumer logic. Message broker server allows consumer and producer server to respond request fast instead of using resources heavily at one time. Message broker is used to optimize the load on the server and provide services until application executes the task on the requested server. The requested server can be any third party application which performs the task.

Queued messages will be used to send the messages or task to multiple recipients from consumption that leads to the load balancing on the producer and consumer server.

Let take an example of ruby on rails server and bitcoin exchange server (i.e. bitcoind) for btc transaction working.

I have rails server running as producer and bitcoind server as a consumer.

Rails server send multiple request to bitcoind server continuously. There may be chances to slow down bitcoind because of multiple requests send to bitcoind server to process task.

In that case, RabbitMQ can fulfill the role of load balancing and messages passing by keeping the request coming from rails server in a queue and serve request one by one to bitcoind server.

Bitcoind server will take a task from the queue and start processing.                                                           

AMQP role in RabbitMQ:

AMQP store and forward messages to consumers, same as SMTP protocol which is used to deliver mail to mailboxes. Messages start from producer application to the exchanges that help to redirect in queues. Lastly, queues deliver task to the consumer application. It's now consumer's server responsibility to take the messages from queues to process as required. 

A virtual channel is used to establish the connection between publishing messages from the queue. All process exchanges done over the channels.

How to use RabbitMQ in Rails application?

Using Bunny ruby RabbitMQ client, we can integrate RabbitMq with rails application. There are some gems available to start with RabbitMQ in ruby like

Bunny help rails application to interoperate with the consumer application, it can be built in any technologies irrespective of the size and complexity of the application. Also, add anampq gem in rails Gemfile to use AMQP protocol services.

RabbitMQ installation commands in Ubuntu:

1] Step 1: Update system
   

2] Step 2: Install Erlang

RabbitMQ is written in Erlang, you need to install Erlang before you can use RabbitMQ:

3] Step 3: Install RabbitMQ

4] Step 4: Start the Server

Thus if you are looking for web development services which is faster, reliable, redundant and scalable then you can definitely opt for Ruby on Rails RabbitMQ. Hire RoR developers for developing a robust messaging software.

Action Cable is a powerful feature introduced in Rails 5. Using action cable one can develop real-time web applications. Action cable uses Web Sockets to create full duplex communication between application’s server and client.

Using action cable feature we can create any real-time functionality like live chatting, which updates chats, show new messages, notifications, etc without reloading of the page. Action cable basically keeps ruby on rails server data and client data updated using web sockets which make the application more feasible to use.

Action cable is not supported by RAILS VERSION > 5.

PREREQUISITES:

This ruby gem requires jQuery. If jQuery is not present in the project then simply add “jquery_rails” gem to gemfile.rb and redis-server in the system.

STEPS REQUIRED TO USE ACTION CABLE:

Add following in Gemfile.rb file :

gem 'redis', '~> 4.0'

Also add following in application.js file :

//= require rails-ujs

//= require jquery

//= require turbolinks

//= require_tree

Thats all about installation process.

Let’s see an EXAMPLE :

For creating Notification model, controller and views using scaffold command just run :

rails g scaffold Notification name:string

Then create a Channel , we call this channel “WebNotifications”.

rails generate channel WebNotifications

And we add some CoffeeScript files to show notifications to all users in javascripts/page.coffee:

App.room = App.cable.subscriptions.create "WebNotificationsChannel",

received: (data) ->

$('#notification div').append '<li>' + data['notification'] + '</li>'

$('#notifications-count,.notifications-count').text data['count'] 

And finally we need to add the below code to the channels web_notifications_channel.rb.

class WebNotificationsChannel < ApplicationCable::Channel

def subscribed

stream_from "web_notifications_channel"

end

def unsubscribed

end

end

Changes in notifications_controller.rb file To call the action cable: 

def create

@notfication = Notfication.new(notfication_params)

respond_to do |format|

if @notfication.save

format.html { redirect_to @notfication, notice: 'Notfication was successfully created.' }

format.json { render :show, status: :created, location: @notfication }

else

format.html { render :new }

format.json { render json: @notfication.errors, status: :unprocessable_entity }

end

end

ActionCable.server.broadcast 'web_notifications_channel', notification: @notfication.name, count: Notification.all.count

end

Changes in app/views/layouts/application.html.erb file : I have added simple notification navigation in the application layouts.

<ul class="nav navbar-nav navbar-right">

<li class="dropdown">

<a href="#" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">Notification (<b class="notifications-count">2</b>)</a>

<ul class="dropdown-menu notify-drop">

<div class="notify-drop-title">

<div class="row">

<div class="col-md-6 col-sm-6 col-xs-6">Notifications (<b id="notifications-count">2</b>)</div>

<div class="col-md-6 col-sm-6 col-xs-6 text-right"><a href="" class="rIcon allRead" data-tooltip="tooltip" data-placement="bottom" title="tümü okundu."><i class="fa fa-dot-circle-o"></i></a></div>

</div>

</div>

<!-- end notify title -->

<!-- notify content -->

<div class="drop-content" id="notification">

<% Notfication.all.each do |notification| %>

<li>

<div class="col-md-3 col-sm-3 col-xs-3">

<%= notification.name %>

</div>

</li>

<% end %>

</div>

</ul>

</li>

</ul>

We need to do simple configuration setup in the cable.yml file.

redis: &redis

adapter: redis

url: redis://localhost:6379/1


production: *redis

development: *redis

test: *redis

To start the application first we need to start the redis-server the command to start the redis-server is:

redis-server

The Redis-server will be started then you can serve your application.
Following are the snapshots of output scenarios:

Creating new Notifications:

The result will be shown like that By using the action cable it will update the Notification to all live users.

In Ruby on Rails web development, using Action Cable RoR developers can show the live notifications to all users. These notifications can be of any type like Messaging, Sending push notification etc.

As software testing is moving from manual into automation at very fast speed, at times testers get into a scenario where they need to opt what needs to be automated, when to automate and why to opt for automated software testing?

If you are a software tester, this blog will help you to choose one from the two testing methods.

Software testers generally perform manual testing in the following scenarios:

1. When an application is at the initial stage of development. As application flow and feel and change over developing period it's better to go for manual testing then automating it. Automation can be done only when the application is stable.

2. When negative testing of the application is to be done because it's more reliable to depend on manual testing.

3. When regression is not required multiple times i.e. there are no multiple executions of test cases.

4. When there are some functionalities which cannot be automated like Captcha.

What is Automated Software Testing?

It is a process in which specific tools are used to execute scripts or test and compare the results. There are various tools available in the market to automate different types of software testing like QTP, Selenium, etc.

Starting with automation first need to take in consideration the following to avoid any confusion.

• Is the build stable?

• Does the application requires testing same functionality many times(Regression/Sanity/Smoke)

• Will writing automated test case save time?

• Do we have that much time to invest in automated testing?

If the answer to this question is YES then you can opt for automation testing for the application. Choosing the right framework for application is all dependent on what you are going to test.

And yes a team of experts for software testing to carry out the process is really important aspect followed by proper planning and strategy.

When to Choose Automated Software Testing?

1. Regression Testing: When we need to test the same test case or functionality multiple times. As testing the same functionality manually make people bore and error chances increase.

2. Large No. of Test Cases: When there is a large number of test cases to execute, it’s better to go with automation where just running the test suite will solve the problem.

3. Time management: As said above executing a large number of test cases manually will take a lot of time and money. So the time can be saved if we are using automation testing.

4. Performance: It's not possible to invest thousands of users to test the performance of any application. Automated testing can generate the required amount of user to interact with application and network.

5. Accuracy: It can be obtained with the help of regression/sanity/smoke testing: one has to just run the script. Manually there is a chance of missing any scenario.

Nowadays, data handling is a big responsibility for every web and mobile application. Arrays make the process easier and it can handle any list of data. Once you have data in an array, you can easily sort it, remove duplicates, change its order to either ascending or descending and many more.

In Ruby programming, there are many methods for Array object i.e. Map, Collect, Select, Reject, Each, Inject, Reduce, Detect and Find. Most of the Ruby on Rails developers uses these methods in their web applications.

In this blog, we have outlined the difference between all the methods.

Let’s have a look at them to choose the one which is best suitable for your requirement.

1. Map

The map method takes each element from the array and evaluates
given block on it. Output will be in the form of an array containing evaluated results without changing the original array.

2. Map!

If you want to modify the original array by replacing the output array elements with the original array elements then you can use the map! method.

3. Collect

There is no difference between collect and map method both methods work same. Similarly map! and collect! methods are also same.

4. Select

The select method takes each element from the array and evaluates given block on it. If block or statement evaluates to true the original elements gets added into the output array. In this case output array and original array are different. If you want to replace the original array to the output array, you can use select! Method.

5. Reject

The reject method is exactly opposite to the select method. It will take each element of the array in the block to evaluate. The output array will consist of all the elements in the original array for which block evaluates to false. The reject! method is also opposite to the select! method.

6. Each

The each method will iterate over array taking each element from it for evaluation. It will return the original array, but not evaluated one. Now, it depends on you what kind of operation you want to perform in the block.

7. Inject

The inject method takes two arguments, one as an accumulator and other as each element in the array. Accumulator accumulates the evaluated values. This returns the final value of the accumulator as a result. The initial value of the accumulator can be defined if not define it takes the first element of the array as initial value.

8. Reduce

Reduce method is similar to the inject method.

9. Detect

The detect method is similar to the select method, but the only difference is its output. The detect method also evaluates a block for each element of the array, but returns the first element in the array for which the block evaluates to true or statement in the block evaluates to true.

10. Find

Find method is similar to Detect method.

If you want to create Rails Application dependent on API only and you have a requirement to provide Token based authentication in your application. So you can use JWT+ KNOCK token based Authentication solution.

Knock is an authentication solution for Rails API-only application based on JSON Web Tokens.

JWT is JSON based web tokens.

Advantages of using JWT and Knock in Ruby on Rails Application:

• JWT:

1. It is lightweight

2. It is easy to use

3. It is stateless

• Knock:

1. Seamless JWT authentication for Rails API

2. It is easy to implement and maintain.

3. It allows customization.

Step 1: Create Rails API Project

rails new project_name --api -d mysql 

where

# --api specifies the rails application is API based

# -d mysql specifies that we use mysql database in this application

Step 2 : Add gem

Add following gem into project_name/Gemfile

gem 'knock' 

gem 'jwt'

gem file looks like

Figure 1: Gemfile for JWT and Knock

Next to run command on terminal for installing gem in application.

bundle install 

Step 3. Setup a basic Knock structure.

Run following command

rails generate knock:install 

rails generate knock:token_controller user

Now run the following commands to setup your Rails application.

rails generate model users 

rails generate controller users 

rails generate controller home

If you add custom model so you can do it

Figure 2: Migration File

Run following command to create User table

rake db:migrate 

Step 4 . Authorization/Knock Setup:

File Location: project_name/config/initializers/knock.rb

Figure 3: Knock.rb file

Step 5. Setup your User model with some basic validation.

File Location: project_name/app/model/user.rb

Your user model look like this.

Figure 4: User.rb file

Now you can setup controller to access the Authentication.

Add include Knock::Authenticable 

File Location: project_name/app/controller/application_controller.rb

Figure 4: Application Controller
 

Also each and every method call pass though knock authentication.

Add before_action :authentication_user, only[:auth]

Here auth is a method to check client is authorized.

In home controller there is index method and auth method for login.

File Location: project_name/app/controller/api/v1/home_controller.rb

Figure 6: Home Controller

File Location: project_name/app/controller/api/v1/users_controller.rb

In user controller there is index, current method for current user data and create method for creating new user. Also you can add update and delete method.

Add authentication on required method with help of authentication_user , authorize_as_admin, and authorize method.

Figure 7: User Controller

Final Step: Test API

We test API with help of Postman.

1. User creation API: API endpoint is http://localhost:3000/api/v1/users/create

We send parameter in body for user creation so that API method type POST. After calling API we get successful response with status 200 and and message “User was created ”.

After user creation we go to login API, but for application login we need a token so we need to call token API.

Figure 8: User create API

2. API Endpoint: http://localhost:3000/api/v1/user_token

For user token we need to send email id and password in body of method type POST.

If email id and password is valid to API we get jwt token from knock in response.

Great we now got token. With help of this we access knock authorized method.

Figure 9: User_token API

3. Login API:

API Endpoint: http://localhost:3000/api/vi1/auth

we sent jwt token in header of API and content type is applicationJson.

Authentication: Bearer jwt token

content type: : applicationJson.

If everything is OK, then we get successful response.

Figure 10: Login with jwt token

These two gems Knock + JWT can help us to develop token based API in Rails 5 very easily and will save the overall time required in Ruby on Rails development.

In this blog we will discuss about Unit Testing, the very first thing that we need to know is when the Unit Testing is being performed. Unit testing is the initial level of software testing, that is performed on the application source code mainly by the developer. The main motive of Unit Testing is to isolate a section of code and verify it’s correctness.

What is Unit Testing:

A level of software testing where the individual units or components of a software or web applications are tested by developer is called Unit Testing. It is an important aspect of Software Testing. It is a component of test-driven development (TDD).

Benefits of Unit Testing:

1. Defects revealed by a unit test are easy to locate and relatively easy to repair. Unit testing verifies the accuracy of the each unit.

2. In unit testing procedure – the developer needs to write test cases for all functions and methods so that whenever a change is required, it can be fixed quickly in later date and the module also works correctly.

3. Unit testing improves the quality of the code. It helps the programmer to write the better code. It identifies every defect that may have come up before code is sent further for regression testing.

4. If a test fails, then only the latest changes need to be made in the code and need to debug. So It’s better to say unit testing helps to simplify the debugging process.

5. Codes are more reusable. In order to make unit testing possible, codes need to be modular. This means that codes are easier to reuse.

Gems to perform Unit Testing in your Ruby on Rails web application:

There are several gems available in Ruby on Rails application framework to perform the unit testing.

• rspec_rails: Rspec is an automated test case, used to test the code written by developer while creating the application.

• factory_girl_rails: create dummy data while performing testing.

• minitest: It is also used to perform the unit testing in your rails application.

These 3 gems given above are used for Test Driven Development (TDD) environment.

• database cleaner: Used to cleanup the database in Ruby while testing.

Most of the Ruby on Rails Developers use the best practices for carrying unit testing on individual units of source code or program modules.

Unit Test Case Best Practices:

• You Should always follow the proper naming conventions for your unit testing, i.e. clear and consistent naming conventions for the unit tests.

• If any changes done in the requirements then your unit test case should not be affected. Your test cases should be independent.

• Always follow “test as your code" approach. The more code you write without testing, the more paths you have to check for errors.

• If any changes needs to done in the code for the corresponding module, make sure that you have the unit test case for that particular module and need to pass the test case before any implementation done.

Conclusion:

Developer should make Unit testing a part of their regime to make neat and clean, reusable, and bug free codes. Also by using unit testing the quality of code will be improved. Unit testing helps to reduce the cost of bug fixes.

We have gone through many web applications and mobile applications which do not reload the entire page but instead reloads only the required section. These are nothing but Single Page Applications (SPA) which are developed using Angular. A good example of SPA is Gmail where we have noticed that when we click on the inbox, it only reloads and displays that email in the e-mail list sections.

Introduction to Angular:

Angular is a TypeScript-base open-source front-end platform and framework led by the Angular Team at Google used for building client-side web applications. Angular itself is written in TypeScript, which is a superset of JavaScript and used for front end development.

Installation:

In order to start with the installation, we first need to make sure that we have nodejs and npm installed with the latest version.

We can install nodejs on Ubuntu OS by running the following command on terminal:

• sudo apt-get update

• sudo apt-get install nodejs

To install npm, we run the following one-line command on terminal:

• sudo apt-get install npm

To check the versions of Node.js and npm installed, we run following command:

• nodejs –v

• npm –v

Let’s install Angular CLI by running the following command:

• npm install –g @angular/cli

IDEs for Angular:

We can use any of the IDE i.e., WebStorm, Atom, Visual Studio Code, etc. But usually, Visual Studio Code is preferred.

Architectural Blocks of Angular:

The main building blocks of an Angular application are:

• Modules

• Components

• Templates

• Metadata

• Data binding

• Directives

• Services

• Dependency injection

In this blog, we will have an overview of Angular Modules and Angular Components.

Angular Modules:

We have Angular modules or we can say NgModules which maintains the modularity of Angular apps. Every Angular app has at least one module as the root module. Conventionally, it is named as AppModule. Typically, an app contains many functional modules. In angular, any module is a class with the @NgModule decorator.

The NgModule decorator is a function that takes metadata object whose properties describe the module. The properties are as follows:

• declarations: Here, we have to declare the classes that are related to views (i.e. The components, the directives, and the pipes that belong to this NgModule).

• exports: Here, we have to mention the classes that should be accessible to the components of other modules.

• imports: Here, we have to mention the modules whose classes are needed by the component of this NgModule.

• providers: Here, we have to mention the Services present in one of the modules which are to be used in the other modules or components. Once a service is included in the providers it becomes accessible in all parts of that application

• bootstrap: Here, we have to mention the root component which is the main view of the application. This root NgModule only has this property and it indicates the component that is to be bootstrapped.

The root module (i.e. src/app/app.module.ts) by default looks like:

Image: The Root Module in Angular

Angular Components

Every Angular application has a root component i.e. AppComponent which is bootstrapped inside the main module. In angular, each component defines a class with the application data and logic and is associated with a view i.e. HTML template to be displayed in a target environment.

The root component (i.e. src/app/app.component.ts) by default looks like:

Image: The Root Component in Angular

Advantages of Angular:

• Angular is faster, lighter and easier framework which is built to create faster performance applications that are smaller in size and easier to develop.

• It provides high performance, offline, and zero-step installation. So, Angular is pretty much easy to work with.

• Angular is universal that means we can use any technology with it for serving the application like node.js, .NET, PHP, Ruby on Rails and other servers.

• Angular is productive as:

• It generates UI templates quickly with simple and powerful template syntax.

• Angular CLI with Command line tools.

Apart from front end development we use Ruby on Rails framework for backend development. Hope this blog would be informative to understand the basic building blocks of Angular.

Introduction to FontAwesome 5:

Font Awesome 5 is upgraded version of Font Awesome 4, It has a more attractive icon with big improvement icons as compare to Font Awesome 4

Some improved points are listed below:

• FontAwesome 5 icons are drawn now with SVG.

• Now we have to reference Javascript file with SVG embedded in place of CSS file ( In FontAwesome 4 we use CSS file only ).

However, version 5 is now redesigned and rewritten from scratch.

Now, Let us see the changes in FontAwesome 5

Different icon styles:

In Version 5, there are 3 different styles:

i) Solid Style

ii) Regular Style

iii) Light Style

“Brand Icons” are separated out into their own style and is easy to use. Version 4 had one prefix only “-fa” and Version 5 has four prefixes. To set a style of any icon with ease, every prefix has different Javascript and SVG file. If we want to use them, we need to import Javascript and SVG file. Some as mentioned below.

Table: Font Awesome 5 Details

Syntax

Version 4’s Syntax

1)<i class=”fa fa-rocket”></i>

Version 5’s Syntax

1)<i class=”fas fa-rocket”></i>-----------“fas ‘s’ for Solid”

2)<i class=”far fa-rocket”></i>----------- “far ‘r’ for Regular”

3)<i class=”fal fa-rocket”></i>----------- “fal ‘l’ for Light”

Note:- Some Icon name changed in the upgraded version.

How to use FontAwesome 5:

Step1: Add Assets for FontAwesome 5 (Version 5)

Download cdn which is required for version 5

Web Font & CSS files

1. css/solid.css

2. css/regular.css

3. css/brand.css

4. css/fontawesome.css

5. css/light.css

6. For all CSS, we can use css/all.css

JS & SVG files

1. js/solid-.js

2. js/regular.js

3. js/brand.js

4. js/fontawesome .js

5. js/light.js

6. For all js, we can use js/all.js

There is one more file that is “ Shims ” file.

Shim file is created to be used as band-aids until you get time to upgrade. Version 4 allows you to keep v4 icon name, aliases, and syntax while mapping Version 5. If we want to use then add below extra line to our Version 5

<link rel=”stylesheet” href=”https://use.fontawesome.com/releases/v5.2.0/css/v4-shim.css”>

v4-shim is used for both Web Fonts + CSS and SVG + JS Frameworks.

If we want to use new and fancy SVG+JS of rendering icon, then switch the “css/all.css” into “js/all.js” also “css/v4-shims.css” into “js/v4-shims.js“

Step2: Add syntax in your HTML file

For Example:

<i class=”fal fa-rocket”></i>

<i class=”far fa-rocket”></i>

<i class=”fas fa-rocket”></i>

An effect you can see in below image:

Image: Font Awesome 5 Comparison

Note: In FontAwesome 5 some icon name are changed, if we don’t want to use them then, we have to add shim file. Version 5 has lots of icon but some icons are paid, if we want to use then we need to buy PRO Version .

Advantages:

1) Icon are designed using SVG and Javascript.

2) Icon Fonts are Ligatures and auto-accessibility.

3) Icon can be re-written, redesigned using CSS and JS.

A scheduled task is very important in Ruby on Rails application. Ruby on Rails does not have this type of “out-of-the-box” feature, but we can use the Cron job to achieve the purpose. Cron can be scheduled to send a reminder email, or scheduling to crawl something from another website on daily basis. In this blog, let’s quickly go through how to use Cron job.

What is CRON?

Cron task is a time-based job scheduler in Unix-like computer operating systems. Cron can be used to schedule jobs to run periodically at fixed times, dates, or intervals. Cron is most suitable for scheduling repetitive tasks in Ruby on Rails applications.

Let’s take an example of sending a daily digest email to persons or users. In this case, we might have a mailer like this using crontab:

#STEP 1.

The user can run any method from the terminal. Here I’m running an action inside a model i.e schedule_rb_method.

Open “app/models/reminder.rb” and then add the method for running an action as shown below.

Run rails runner “Reminder.schedule_rb_method” command inside the project path on the terminal, to check method is running or not.

#STEP 2.

Set the default rvm to the project.

run rvm --default use 2.5.0

#STEP 3.

Creating a Crontab:

Cron is driven by a crontab (cron table) file, a configuration file that specifies shell commands to run periodically on a given schedule.

Users can have their own individual Crontab files in the system.

It’s pretty easy to start working with cron jobs in rails. You can start editing your cron tasks using the crontab command on your terminal:

Open your terminal: run crontab -e

This command will open a text file in your terminal’s default editor.

#STEP 4.

We are going to enter a line into this crontab file. It will have the following structure:

[timings] [switch to your app directory] && [path to ruby] script/runner -e [environment] “[model class name] . [ (run method name) path to cron log]”

By looking at the above line to understand: Run a task every day at 10 am.

1. If you try and save your crontab and you receive errors, make sure the whole command is in one line on your terminal.

2. If your model method runs OK, you should either get some mail as mentioned in the cron. However, if there is an error, you must check your cron method to check the log you created in rails to understand the error.

    

Crontab Syntax:

Once you’re in the editor, you can start creating and editing cron tasks in rails. To schedule a cron task, you need to define when the task will run, then define the command to trigger that task.

There are 5 variables that can be changed inside a cron task in Ruby on Rails application:

• 1st variable: Minute, which can be specified from 0 to 59 min

• 2nd variable: Hour, which can be specified from 0 to 23 hr

• 3rd variable: Day of Month, which can be specified from 1 to 23 day

• 4th variable: Month, which can be specified from 1 to 12 month

• 5th variable: Day of Week, which can be specified from 0 - 6 (Sunday = 0) week days

If the variable is a “*” it means for all.

If the variable is a series of number split by a comma “,”, it means OR condition on each of the specified number in Cronjobs.

Example:

Timing Format: 
minute   hour   day   month   weekday
0 30      *      *      *      *   example command to be executed

While cron jobs are useful and can get the job done in many instances, you should be careful in your decision of how to implement scheduled and delayed tasks in Ruby on Rails application.

In rails, Cronjobs are best for tasks that are not highly critical or essential to your application’s functionality or performance. They should also execute in a reasonably short amount of time so that they don’t bog down your rails server(s).

Every University has thousands of applications streaming in for each course. A single application has a minimum of three stages – the document submitted by the student, his/her interview and finally, uploading the financial proof. Managing all of this singularly is a huge challenge.

There is a strong need for providing a common platform for application management. Offshore System for Student Management, a software developed and managed by Cryptex Technologies, India is the perfect one-stop solution for this. This application is developed using Ruby on Rails technology.

It is integrated with a dashboard showcasing the various features of this application, you can easily navigate around to make your work easier.

The dashboard has options for viewing the student application checklist, interview scheduling and feedback, advanced search functionality, along with the financial document submission and COE.

A database of a thousand and more entries can be filtered according to the search requirement. You can generate reports for specified time durations in the form of graphs and charts.

An export data feature is introduced in this to export the online data directly to your desktop.

Another added feature of OSSM is that of accessing the information of the agent via whom the student has applied. This helps during future decision making, giving a constructive insight into the work done by each of the agents.

Having a consolidated application for admission procedure is a one-time solution for eliminating all the manual efforts and errors.

Contact us if your needs are similar to this and we will build a smooth student management platform for you.

Cryptex Technologies

Plot No.8, Gopal Nagar,Nagpur-440022,
Maharashtra, India

Contact No: +91-712-223-2300

Email ID: info@cryptextechnologies.com

Redis is an open source very fast, non-relational, in-memory data structure store. It stores data in the form of a key-value pair. Redis has a support of data structure like sets, hashes, strings, list. Redis is mostly used for the cache store.

When to use Redis?

Redis is used when we have a performance issue related to scalability. For example when we have data in the database which is not going to change frequently then you use Redis to cache that data to remove the load from the MySql or PgSql server.

How to use Redis in Ruby on rails?

In order to use Redis in Ruby on Rails application you have to follow the steps given below:

Step 1:

Add the following gem into the Gemfile of application and run the “bundle install” command.

Step 2:

Next is to create redis.rb file in config/initializers directory and add the following code into that file 

In the above code “app_name” is the Namespace of my application. Gem “redis-namespace” organize everything under one application wise namespace, when multiple applications use same Redis server.

Step 3:

Next, to instruct rails to use Redis as a cache store we have added following code into application.rb file.

Step 4:

In the below code I have written a query in booths_controller.rb file to fetch all booths of size 16m2. And write a helper method in booths_helper.rb to fetch the data from Redis.

In the above code when we call the new_booth method of booths_controller, it will call the fetch_booths_16 helper method.

In this fetch_booths_16 method, the booths_16 will get nil value because no data is pushed into redis yet. We then instruct rails to push booths_16 data into redis. Then after a subsequent call to this method, data will be fetched from redis.

Since we are loading data in new_booths as a json we have to change when you call @booth_size_16.name to @booth_size_16[“name”] because data is in the form of json.

Advantages of using Redis:

• Support for rich data structure types: hash, string, set, list, sorted etc.

• Data is stored in memory and retrieve quickly: Redis store data in memory so instead of requesting data from the server it will fetch from memory and retrieve data very quickly

• Redis is used to speed up service response.

• Redis is a very fast non-relational and NoSQL key-value pair data store.

• Redis allows to insert a large amount of data into its cache very easily: Sometimes a situation comes like we have to load a thousand pieces of data into cache in a short period of time. This can be done by Redis, with mass insertion feature of it.

• Redis uses “Redis hashing” which is its own hashing mechanism: Datastore in redis in the form of key-value pair i.e. string field and a string value.

Redis offers efficient caching mechanism and it will take very less time to implement this cache mechanism. But outcomes of using this will get high-performing cache system in our application.

So this is the way you can improve the performance and increase the scalability of Rails application to a great extent.

In this blog, you are going to learn about the deployment of rails application on the production server with its configuration setting in Apache. For this, you need to have Ruby, Rails, MySQL installed in your server system.

Let’s begin with the process of deploying the Rails application.

Step 1: Add the code copy to the server.

          For adding code to the server, you need to take a copy of the code on your server by login using sftp.

$ sftp user@yourserver.com

$ put samplecode

Step 2: Installation of project and configuration settings.

          Install all libraries of the project and make configuration settings including configuration of database.yml and secrets.yml by using following commands. For this, you need to login to the server using ssh and go to the project folder.

$ ssh user@yourserver.com

$ cd samplecode

          Rails app has ruby versions and you have to use that specific version to run the application. So, use the ruby version of the application.

$ rvm use (ruby version)

          Install all libraries of the project, set the database and compile assets. Rails have some specific commands to do that.

$ bundle install

$ rake db:create RAILS_ENV=production

$ rake db:migrate RAILS_ENV=production

$ rake assets:precompile RAILS_ENV=production

          Rails provide a secret key which you have to mention it into the config/secret.yml file of the application to maintain the security.

$ rake secret

Above command provide a secret key, add it to the config/secrets.yml file of you RoR project.

Step 3: Apache settings

          You have to do apache settings to run the application in production mode on apache server. For this first, you have to create samplecode.conf file in etc/apache2/sites-available/ path.

The file content will look like as in Image 1. Where you have to mention the domain of your application like www.myapp.com and server name like myapp.com. With this, you also have to mention the path of a public folder of the application and ruby version of the application.

Image 1: Samplecode.conf File

You need to create the symlink of the file samplecode.conf to the sites-enabled folder.  It is created for apache and virtual host settings. This virtual host setting will tell Apache where your application is located. Replace myapp.com with your application name and as well as mention path to ruby with the ruby version of the application into the samplecode.conf file.

          If you start the application on some port and not on some domain like www.myapp.com, you need to specify the port number in the conf file in place of port “80” at the top of the file. And then mention that port to the ports.conf file which is located at /etc/apache/ports.conf.

Image 2: Ports.conf File

In the above image, you can see how to mention port, like I have mentioned port 3000 to be heard by apache while serving the page. At last restart the apache server by using the following command. It will run the application on the link like 127.0.0.0:3000 or if it is for a domain then it will run on www.myapp.com or myapp.com.

$ sudo restart apache2 restart

In this way, you can start a rails app on the production server.

In my coding lifetime, I have enhanced and improved my coding style after client feedback and guidance. I have learned over the years of time, that there aspects and points that has utmost importance in the coding of Ruby on Rails (RoR) application.

We as developers start writing code without actually analyzing and understanding the code requirement as well. A messed up code is no one’s favorite and not to be delivered.

I am sharing my thumb rules that will surely help you as it did to me.

Rule No. 1: Indent your code

What if you are given a much messed up code to update? I am sure you will get frustrated; in order to write very clear code keep it well indented. In Ruby on rails, though the auto-generated code is four space indented style we should use two spaces to intend our block of code as this is most widely adapted style. This improves the readability of our code.

Rule No. 2: Name it well!

Naming convention should be followed as this is helpful for us to understand the purpose of it and at certain places, active record in ruby also works on the basis of names.

Active record uses the same naming convention in order to find out how the mapping between the models and database tables are created.

Say for example a class “Category”, should have a database table called “Categories”. The rails pluralization mechanism is very powerful such that it is capable of pluralizing both regular and irregular words.

When it comes to naming a variable, you should follow CamelCase form, which says that the first word should start with a small letter and the next word should start with a capital letter, e.g. “categoryOne”.

When the table name has two words, it should be separated by “_” , e.g. “book_categoryies”. When it comes to model class, it should be singular with the first letter of each word capitalization e.g. “CategoryBook”.

Similarly, the name of methods should be such that it should define the purpose of that method, for e.g. “category_list”.

Rule No. 3: Less If else, Less complex

If else statement is a block of condition where you check the condition if it is true or false.

Using the number of if-else statement creates makes the code bulky. It will increase the number of lines in the code, which can be reduced or should not be used at all. It also makes the code complex and not easy to understand.

Rule No. 4: Use of a number of variables

What do variables do in rails? It allocates the memory for which it is assigned for. When the expression can be directly assigned or can be directly passed, a variable should not be used as this will be the unnecessary allocation of memory, unnecessary declaration of a variable.

In Ruby on rails development, we have four different types of variables global variables, class variables, instance variable and local variables.

Global variables are accessible globally in the application which means it can be modified from any part of the program hence it let to lack of security of our code.

Hence it is recommended not to use global variables.

Always try to replace instance variable with local variable as local variables are accessed locally which ensures the security of our code.

Rule No. 5: Put-up a comment there

Comments are the description written in the source code within the special character so that it should be ignored by the compiler.

What if, you get a new project with some classes having methods in it? Will you be able to understand the purpose of it?

Even, if the method name is good enough? No, sometimes only method names do not help in recognizing or understanding the main purpose of the method or how it works, hence your method should be well commented in order to let others also understand its basic purpose.

Rule No. 6: Don’t put too much logic in the view, make use of helpers, create them!

Views are specially meant for displaying the data hence it should not have too much logic, this can be done by making use of helpers, if the piece of code is used many times in a view, make a helper and call it in a view.

So, these are my six thumb rules while writing code, from the time that I have become the developer. These have helped me and can be taken as consideration to make your code scalable, robust and secure.

This will add sparkle to your code, which will eventually make your client happy! :)  

If you have a different lookout, let me know your views, in the comments section below.

Automated testing is extremely on the boom, across the board nowadays and obviously Ruby has its own arrangements to make it work for Ruby on Rails developers. One of these is RSpec, a madly prevalent tool for mechanized testing. The fortunate thing about it is we can test almost every part of RoR Application easily.

Rspec is easy to get it up and running, expressive way to write test cases, easy to use and also fast.

Let’s start with assembling all the components together to start with:

To begin it’s necessary to install Ruby. You can do it from here for Windows OS:  http://www.rubyinstaller.org

After completing installation let’s check if Ruby is installed properly along with version number.

• For this go to command prompt and type:

                 ruby -v

        You will get the following result.

• Next, you need to install RSpec gem. Gem is Ruby library which can be used in one’s own code.
• Go to command prompt and type the following :

       gem install rspec

       You will get the following output:

    Done installing documentation for diff-lcs, rspec-support, rspec-mocks,

rspec-expectations, rspec-core, rspec after 22 seconds 

6 gems installed

• To start with Selenium in Ruby you also need to install the gem selenium-webdriver which will act as a binder for Ruby from the command line.

Type the following command to install ‘selenium-webdriver’:

gem install selenium-webdriver

• Now, create directory i.e. folder to store Rspec scripts. Open your command prompt and change the directory path to the one where you would be saving your scripts.

Example: If your directory name is ‘sample_scripts’ on desktop:

C:\Desktop\sample_scripts>

Let’s start with writing script in Rspec.

So for this open any editor. Here, I have used sublime.

• Write the following code in the sublime editor and save it. Save it with name sample.rb

• To run the script go to command prompt and type:

C:\Desktop\sample_scripts>rspec sample.rb

 You will get the output as following after executing the script:

 Finished in 0.002 seconds (files took 0.11101 seconds to load)   1 example, 0 failures

Keywords in Rspec:

As this is targeted to new coders, you need to know some keywords which are meant to be used in your code. This helps in understanding the protocol to be followed while coding.

• describe..... do

Description of the collection of related test cases

• it......do

Individual test cases

• Before() and After()

Optional test statements run before and after each or all test cases.

So, let’s hope you have understood the significance of using RSpec while automation testing.

This reduces your time to test & increases the efficiency of testing.

The code quality is needless to mention becomes high.

All these steps are for test-driven development (TDD) environment if you want to know how to use RSpec in Behaviour Driven Development (BDD) please refer our previous blog about it.

Aren’t we testers meant to have this as our focus? This is all about the beginning of using RSpec in your Ruby on Rails Development process.

When working in a team, you may have come across a situation wherein there are many copies of Code of your Ruby on Rails Application and then you really don't know if it has been updated,well-organized or well merged, for that matter, haven’t you?

Well, GitHub is your solution to the same.GitHub is that platform that I rely a lot on my coding. Be it organizing, updated code or merging code, this platform takes care of it all.

GitHub is a code hosting platform for version control and collaboration. It is a very useful tool that allows you to work in any geographical location.

GitHub is the most powerful platform for management and review of the code. Github is used for managing the code on the single platform. Using GitHub you can track the changes of each commit. Github also provides public and private repositories. The public repository is most commonly used for open source software applications.

Let’s learn:

• How to create a repository in a GitHub?
• How to create new branches and manage these branches in  GitHub?
• How to push your code in GitHub?
• How to manage commits?
• How to create and manage pull request GitHub?.

I’ll start considering you a RoR developer and then, of course, you know how to create your account in GitHub. Well, You should know that!

        On Logging into GitHub, you’ll find many options and parameters but for a kick-start to committing codes in GitHub, first, you need to create a repository.

     Create a repository in a GitHub :

The GitHub repository is a  virtual directory or space where we can access your project, its files, and all related data.

On click of new repository button, you will be redirected to new directory form page. You need to follow the below steps to create a new repository in GitHub.