Notes posted to Ruby on Rails

RSS feed
August 10, 2017 - (v2.2.1 - v4.2.7)
0 thanks



The Exception Notifier plugin provides a mailer object and a default set of templates for sending email notifications when errors occur in a Rails application. It is basically a monitoring tool, which keeps on watching the application and whenever it finds any error, it triggers that error to PagerDuty. To use Exception Notification and PagerDuty in your app, you need to add this gem below:

gem 'exception_notification', '~> 4.1.0'

gem  'pagerduty''

To get the email notifications, you need to include the line below in the development env:

Rails.application.config.middleware.use  ExceptionNotification::Rack,
                 :email => {
                  :email_prefix => "[PREFIX] ",
                  :sender_address => %{"notifier"  <notifier@example.com>},
                  :exception_recipients => %w{exceptions@example.com},
                  :pd => {
                           # simple notifier options

You can modify sender’s and recipient’s address.

Rails App+PagerDuty

Use the code below in your app with exception notifier to connect with PagerDuty:

require "pagerduty"
module ExceptionNotifier
      Class PdNotifier
          def initialize(options)
            @pagerduty =   Pagerduty.new("0bdcfdacf1b144d7822dfdfa5ed0ab1e")# Service api key
           # do something with the options...
        def call(exception, options={})
           @pagerduty.trigger(exception.message, details:  { backtrace: exception.backtrace })


PagerDuty is alert dispatching tool used by operations team/OnCall Engineers to manage the applications and it is popular because of its reliable & rich services(Scheduling,Alerting,Reporting,Call Routing , Feedback & response time).

Create your Free account from app.pagerduty.com/ and integrate with your application to get the flow , how Incident is triggered.

June 28, 2017
0 thanks

How to use Textacular Gem to search data in your Rails Application

We might have heard about a lot many gems which let us implement search functionality in our rails application; for example: searchkick, elasticsearch-rails, ransack and finally, sunspot to work with solr search engine. All these gems have their own advantages. Both searchkick and elasticsearch use redis to search the data as well as need to perform a ‘reindex’ while inserting new data. In one of my recent projects, I happened to use a gem called as Textacular. It’s simple and very easy to use. Textacular Gem:

It is a gem that provides full text search capabilities for PostgreSQL Database. It basically caters to extend the scope of the work performed by activerecord, in a rather friendly manner. It works on heroku as well. This gem works only on PostgreSQL For working with it, let’s first grab the latest textacular gem from rubygems.org/gems/textacular and add it to the gemfile.

gem 'textacular'
    bundle install

Textacular gem provides us with quite a few methods to search the data. So, all our models have the access to use those methods.

basic_search advanced_search fuzzy_search

Usage: Basic_search: It searches based on the input text.

User.basic_search(‘abc’) # Searches on all the model column attributes

User.basic_search(last_name: 'abc', first_name: 'xyz')

Advanced_search: Here, we can use postgres syntaxes like !, & and | (and, or and, not) and then, some others based on the requirement. It converts user’s search DSL into Pg syntax. For this, we need to make sure that the necessary exceptions should be used to handle the syntax errors.

User.advanced_search(last_name: 'text1|text2’) - It  searches with the text1 or text2 on last_name on User  model.

User.advanced_search(last_name: '!text2’) - It searches for the records whose last_name is not text2.

These searches can be chainable as shown below:

User.advanced_search(last_name: 'text1|text2’).basic_search(last_name: 'abc', first_name: 'xyz')

Fuzzy_search: We need to install pg_trgm module to work with fuzzy_search. Run the command below to install this module. It searches for partial appearance of your text in the DB.

rake textacular:create_trigram_migration  
rake db:migrate

Now, we are ready to use fuzzy_search.


By default, fuzzy search, searches for the records which are 30% of the search text matches with respect to the entire content. We can set this threshold limit by using the command below.

ActiveRecord::Base.connection.execute("SELECT set_limit(0.6);")

So, it expects 60% of search text to match with the original content. We can use OR condition to search on multiple columns. Need to pass a hash with columns with input text as param one and pass second param as a false. It takes AND, if you miss second param or if it True.

User.fuzzy_search({first_name: 'user', last_name: 'test'}, false)

User.fuzzy_search(first_name:user’, last_name: 'test') - It takes AND condition.

By default, the Textacular searches in all text and string columns. We can alter its default behaviour by overriding the searchable_columns method in the model.

def self.searchable_columns
   [:title, :body]

We can override self.searchable_language in the model to set proper dictionary settings.

def self.searchable_language 

Read More : http://www.railscarma.com/blog/technical-articles/how-to-use-textacular-gem-to-search-data-in-your-rails-application/

March 29, 2017
0 thanks

multiple select has a hidden

It’s unclear if “select_tag” does this but the normal select method also generates a hidden variable if the “multiple” option is set, see http://apidock.com/rails/ActionView/Helpers/FormOptionsHelper/select

March 29, 2017
0 thanks

not submitted even if non-multiple in certain cases.

As a note, just for followers, even if a select is not “multiple” if it is “unselected” (ex: in javascript you can set its value like document.getElementById(‘select_id’).value = ‘a non option’; ). And if that form is submitted, the browser also seems to not send anything about it to the server. So it’s for non-multiples as well, just this case is rare since typically the select will default to its “first value” and then users can only change it another known value, so typically you won’t run into that. This isn’t related to rails but thought I’d mention it.

March 2, 2017
0 thanks

Converting Hash to Struct in Ruby

With the fact we know about the two, many will perhaps prefer using struct rather than hash. But what we want to focus here is that behind the low performance given by hash, they still can become advantageous. If you can’t use it on its own little way, then convert it into struct so better usability can be achieved.

If you have already defined the struct and you wanted to initiate converting hash to struct, we can help you by using the following methods in a given example below. If you wanted to convert has to a struct in Ruby, let us say for example we have a given of:

h = { :a => 1, :b => 2 }

and want to have a struct such as:

s.a == 1
s.b == 2

To convert, you can do any of these methods: Conversion Method 1:

On this method, the result will appear to be OpenStruct and not specifically as struct:

pry(main)> require 'ostruct'
pry(main)> s = OpenStruct.new(h)
=> #<OpenStruct a=1, b=2>
pry(main)> puts s.a, s.b

Conversion Method 2:

If you have struct defined already and want to start something with a hash, you can follow this:

Person = Struct.new(:first_name, :last_name, :age)

person_hash = { first_name: "Foo", last_name: "Bar", age: 29 }

person =  Person.new(*person_hash.values_at(*Person.members))

=> #<struct Person first_name="Foo", last_name="Bar", age=29>

Conversion Method 3:

Since the hash key order was guaranteed in the Ruby 1.9+, you can follow this:

s = Struct.new(*(k = h.keys)).new(*h.values_at(*k))

The hash to struct conversion example we provided can help, but if you want a more extensive idea, come to professionals for formal assistance. Read More From Here http://www.railscarma.com/blog/technical-articles/guide-converting-hash-struct-ruby/

February 1, 2017 - (v4.1.8 - v4.2.7)
0 thanks

association our data

we can load our data whenever we want.

ActiveRecord::Associations::Preloader.new.preload(@users, :company)
February 1, 2017 - (v4.1.8 - v4.2.7)
0 thanks

Preload our own with out incude

we can preload our data whenever we want.

ActiveRecord::Associations::Preloader.new.preload(@users, :address)
January 24, 2017 - (v4.0.2 - v4.2.7)
0 thanks

How to use belongs_to in Ruby on Rails

Rails 4: Let’s assume we have two models Movie and Actor. Actor has many movies and Movie belongs to Actor. In most of the cases, the developers used to validate the foreign key actor_id is present or not. In this case, it will not validate actor model as to whether the entered actor id exists or not. It is just like attribute validation which always validates that the fields should be non-empty when submitting the form.

Validation with foreign key:
class Movie < ApplicationRecord
belongs_to :actor
validates :actor_id, presence: true

class Movie < ApplicationRecord
belongs_to :actor
validates :actor_id, presence: true

class Actor < ApplicationRecord
has_many :movies, dependent: :destroy

class Actor < ApplicationRecord
has_many :movies, dependent: :destroy

The scenario above, validates actor id presence or not like normal attribute presence validator.

Ex: Actor.create(title:abc”).
=> {id: 1, title: 'abc'}
m = Movie.new(title:ok ok”, actor_id: 111)
=> m.valid? => true
=> Actor.find(111)
ActiveRecord::RecordNotFound: Couldn't find Actor with 'id'=111

Ex: Actor.create(title: “abc”).
=> {id: 1, title: 'abc'}
m = Movie.new(title: “ok ok”, actor_id: 111)
=> m.valid? => true
=> Actor.find(111)
ActiveRecord::RecordNotFound: Couldn't find Actor with  'id'=111

We can still save the movie record without valid actor.

With associations

class Movie < ApplicationRecord
belongs_to :actor
validates :actor, presence: true

class Movie < ApplicationRecord
belongs_to :actor
validates :actor, presence: true


class Movie < ApplicationRecord
belongs_to :actor, required: true

class Movie < ApplicationRecord
belongs_to :actor, required: true

class Actor < ApplicationRecord
has_many :movies, dependent: :destroy

class Actor < ApplicationRecord
has_many :movies, dependent: :destroy

Ex: Actor.create(title:abc”).
==> {id: 1, title: 'abc'}
m = Movie.new(title:ok ok”, actor_id: 111)
==> m.valid? => false
==> m.errors.full_messages, ['Actor can't be blank']

Ex: Actor.create(title:abc”).
==> {id: 1, title: 'abc'}
m = Movie.new(title:ok ok”, actor_id: 111)
==> m.valid? => false
==> m.errors.full_messages, ['Actor can't be blank']

In this case, it will always validate whether the entered actor exists or not. In case of an invalid actor it throws error to you. This is the best practise to make your associations. It always checks for the associated object exists or not.

Rails5 From rails5 these validations were added by default. It validates association object should be present when you define belongs_to associations.

Release notes http://guides.rubyonrails.org/5_0_release_notes.html(belongs_to will now trigger a validation error by default if the association is not present.)

We can opt out of this feature completely from the application by setting config opton in initializer file.



Rails.application.config.active_record.belongs_to_required_by_default = false Rails.application.config.active_record.belongs_to_required_by_default = false

This initializer file is present in rails5 application only. Need to add this initializer file manually when you migrate from older version of your rails application and make necessary changes.

class Post < ApplicationRecord
has_many :comments, dependent: :destroy	

class Post < ApplicationRecord
has_many :comments, dependent: :destroy	

class Comment < ApplicationRecord
belongs_to :post

class Comment < ApplicationRecord
belongs_to :post

c = Comment.create(title:awesome post”)
=>Post must exist”

c = Comment.create(title:awesome post”)
=>Post must exist”

We can not create any comment record without an associated record.

We can opt out this default behaviour by setting

belongs_to :post, optional: true
belongs_to :post, optional: true
c = Comment.create(title:awesome post”)
c = Comment.create(title:awesome post”)
=> <Comment id: 1, title:awesome post”, post_id: nil>


December 30, 2016
0 thanks

Used within collection_check_boxes

Note the checked: option.

  = collection_check_boxes(:ahj_types, :ids, AhjType.order(:TypeName), :AHJTypeID, :TypeName) do |b|
      %td{style: 'padding: 0 1em;'}
        = b.label(class: "check_box")
      %td{style: 'padding: 0 1em;'}
        = b.check_box(class: "check_box", checked: (params[:ahj_types][:ids].member?(b.value.to_s)))
December 9, 2016
0 thanks

dealing with semicolon

Use tag! method if you have semicolon, for example:

xml.tag!(“atom:link”, “href”=>“http://rubyplus.com/episodes.rss”, “rel”=>“self”, “type”=>“application/rss+xml”)

December 1, 2016
0 thanks
November 28, 2016
0 thanks

Track Changes To Your Model’s Data with Paper Trail Gem

Paper trail lets us track all the changes in the models data for the purpose of its editing and versioning. By using this gem, we can see how a model looks, at every stage of its life-cycle and we can take it back to any version of the model data and we can even undo all the changes after a record has been destroyed so as to restore it completely.

gempaper_trail’ run bundle install to install it

After bundle install you can run the following command for adding versions table to your database

bundle exec rails generate paper_trail:install

bundle exec rake db:migrate

Add has_paper_trail method to your models for tracking.

class Product < ActiveRecord::Base


If you are using a current_user method then you can track who is responsible for particular change by the below callback

class ApplicationController

before_action :set_paper_trail_whodunnit end

Features of paper trail gem

It stores each and every change happened in the model  like create, update and destroy
It does not store any updates unless if any modifications
It allows you to get every version including the actual and even once destroyed

Basic Usage

Now you have a versions method which returns all the changes in particular model

product = Product.find 2


# [<PaperTrail::Version>, <PaperTrail::Version>, ...]

Based on the vesrion you can find the changes that happened in a model

v = product.versions.last

   v.event # it returns update / create / destroy
   v.whodunnit #it returns a user id who did this
   v.reify the poduct as it was before the update

you can navigate versions by using previous_version and next_version methods

product = product.previous_version

   product = product.next_version #it returns nil if there is no object

   product.versions.last.whodunnit #it returns the user who did the particular change

For More Read From Here : http://www.railscarma.com/blog/technical-articles/track-changes-models-data-paper-trail-gem/

November 8, 2016
0 thanks

Ways of Handling PayPal Refunds in Rails

PayPal Checkout includes payment solutions ranging from simple to robust that let the merchants as well as developers choose an integration option that can be the best-suited for their website and customers. In order to integrate Paypal Payment Gateway, we need to do the following:

  1. Have a PayPal business or Premier account.

  2. Create a PayPal app and get an access token. When we create a PayPal app, PayPal generates a set of OAuth client_id and secret keys for the application. PayPal generates these keys for both the PayPal sandbox and Live environments. To get an access token, pass the client-id:secret credentials in the Authorization header. We use the access token for authentication when we make REST API requests.

  3. To perform an end-to-end test of our Express Checkout with In-Context integration, create both merchant and buyer accounts in the PayPal sandbox environment.

www.sandbox.paypal.com/in/webapps/mpp/home Merchant : Select the Business account type and enter an email address and password. Buyer : Select the Personal account type and enter a high PayPal balance, such as 5000.

Once we create Paypal sandbox account then click on the “Profile” link for that account, look under the tab “API Credentials”. We will have the following information;

Paypal API Username
Paypal API Signature
Paypal API Password

Note: When we are ready to go live we would just use the credentials from our real paypal account instead of the ones from our sandbox account. The credentials can be found in the “My Profile” area under the left hand tab “My Selling Tools” under the option “API access”

How to handle Paypal refunds in Rails:

Method 1:

Paypal Rest API;

For more complex merchant sites, direct calls to PayPal APIs for an Express Checkout integration may be a more appropriate integration. REST APIs — We can develop an Express Checkout integration using PayPal REST APIs.

To integrate the Express Checkout with In-Context flow; developer.paypal.com/docs/api/ OR PayPal REST API Ruby SDK (paypal-sdk-rest gem): The PayPal REST SDK provides Ruby APIs to create, process and manage payment.

Installation: Add the gem our application, in Gemfile:

gem 'paypal-sdk-rest'

And then execute:

$ bundle install


rails g paypal:sdk:install

Refunds a transaction: Any transaction we can issue a refund (Both direct and captured payments):

Refund a completed direct payment (sale)
Refund an authorized and captured payment (capture)

Refund a completed payment (sale): If we must refund a completed payment, or sale, provide the sale id given to us in response to a completed payment along with an empty JSON payload for a full refund and for partial refunds, we can instead include an amount object in the JSON payload.

curl -v https://api.sandbox.paypal.com/v1/payments /sale/CARMAXYZC6136044L/refund \
-H "Content-Type:application/json" \
-H "Authorization: Bearer Access-Token" \
-d '{}'

Note: We should substitute all call-specific parameters, such as tokens and IDs, with our own. Response state of the refund:

pending- The refund is pending.
completed- The refund has successfully completed.
failed- The refund failed.

Refund a captured payment; We can also refund a captured payment: API:


Note: We must provide an amount object for both full and partial refunds.

curl -v https://api.sandbox.paypal.com/v1/payments/capture/CARMAXYZC6136044L/refund \
-H "Content-Type:application/json" \
-H "Authorization: Bearer Access-Token" \
-d '{
"currency": "USD",
"total": "50.54"
"description": "This is the capture refund description."

Reference: https://developer.paypal.com

Method 2:

Paypal refund by using Active Merchant Gem:

ActiveMerchant Integration: http://railscasts.com/episodes/145-integrating-active-merchant

In our Application;


config.after_initialize do

ActiveMerchant::Billing::Base.mode = :test
::GATEWAY = ActiveMerchant::Billing::PaypalGateway.new(
:login => "seller_1229899173_biz_api1.xyz.com",
:password => "FXWU58S7KXFC6HBE",
:signature =>AGjv6SW.mTiKxtkm6L9DcSUCUgePAUDQ3L- kTdszkPG8mRfjaRZDYtSu"



Refunds a transaction: Take a look into paypal_common_api.rb file in Active Merchant Gem;

  1. For a full refund pass nil for the amount:

gateway.refund nil, 'CARMAXYZC6136044L'

This will automatically make the :refund_type be “Full”.

  1. For a partial refund just pass the amount as usual:

gateway.refund 100, 'CARMAXYZC6136044L'
def refund(money, identification, options = {})
commit 'RefundTransaction', build_refund_request(money,  identification, options)


Gateway.refund(nil,'CARMAXYZC6136044L') => Full Refund.

Gateway.refund(798,'CARMAXYZC6136044L') => Partial Refund.

Reference: http://www.rubydoc.info/github/Shopify/active_merchant/ActiveMerchant/Billing/PaypalCommonAPI

Method3: Read More From Here==> http://www.railscarma.com/blog/technical-articles/ways-handling-paypal-refunds-rails/

October 27, 2016 - (<= v3.2.13)
1 thank

An example, with expiration time set


Rails.cache.fetch("out_of_stock_products", :expires_in => 5.minutes) do
  Product.all.joins(:inventory).conditions.where("inventory.quantity = 0")
October 17, 2016
0 thanks

How to generate & add sitemap to your Rails Application

Generate Sitemap: Required Gem: Sitemap generator:- github.com/kjvarga/sitemap_generator

SitemapGenerator is the easiest way to generate Sitemaps in Ruby. Rails integration provides access to the Rails route helpers within our sitemap config file and automatically makes the rake tasks available to us. Or if we prefer to use another framework, we can! We can use the rake tasks provided or run our sitemap configs as plain ruby scripts.

Sitemaps XML format:

The Sitemap protocol format consists of XML tags. All data values in a Sitemap must be entity-escaped. The file itself must be UTF-8 encoded.

The Sitemap must: Begin with an opening <urlset> tag and end with a closing </urlset> tag. Specify the namespace (protocol standard) within the <urlset> tag. Include a <url> entry for each URL, as a parent XML tag. Include a <loc> child entry for each <url> parent tag.

All other tags are optional. Also, all URLs in a Sitemap must be from a single host, such as www.xyz.com or estore.xyz.com. For more details: http://www.sitemaps.org/protocol.html

How to add a sitemap to a Rails app:

1, View for your sitemap:

# app/views/mysitemap/index.xml.erb

2, At your Controller: Let it be our object in view is @articles variable. It needs to get that from a mysitemap controller:

# app/controllers /mysitemap_controller.rb
MysitemapController <  ApplicationController
 layout nil
  def index
 headers['Content-Type'] =  'application/xml'
respond_to do |format|
 format.xml {@articles =  Article.all}

3, Add a route:

# config/routes.rb
get 'sitemap.xml', :to =>  'sitemap#index', :defaults =>  {:format  => 'xml'}

How to convert XML file to HTML: Read From Here http://goo.gl/Vp3chb

October 3, 2016
0 thanks

How To Generate a Swagger Docs For Rails API

Making API for a Rails application is simple for a Ruby on Rails developer. In any case, how different clients/customers will know whether the API is working fine or not without a customer side application. Is there any answer for this which I can report for API inside the Rails application, The answer is yes we have numerous instruments and methodologies however I would favor swagger UI.

In this article I am going to disclose how to make Rails API documentation using swagger UI.

Prerequisites:- I am going to use one sample posts application which serves API calls.

Gem:- To Integrate swagger UI for Rails API I am using a gem called swagger-docs. Add this gem to your Gemfile in your application and do bundle install.

Swagger initializer file:- After bundling the gem create an initializer in config/initializers(e.g. swagger.rb) and specify the following options:

#File config/initializers/swagger.rb


"1.0" => {

# the extension used for the API

:api_extension_type => :json,

# the output location where your .json files are written  to

:api_file_path => "public/apidocs",

# the URL base path to your API

:base_path => "http://localhost:3000",

# if you want to delete all .json files at each generation

:clean_directory => true,

# add custom attributes to api-docs

:attributes => {

:info => {

"title" => "Your application title",

"description" => "Rails API documention with Swagger UI.",

"termsOfServiceUrl" => "",

"contact" => ""





Refer below url for the list of configarations


swagger_controller and swagger_API are helpers to provide swagger UI documentation.

module Api

module V1

class PostsController < ApplicationController

respond_to :json

swagger_controller :posts, 'Post Controller'

swagger_api :create do

summary 'Creating posts'

notes 'Should be used for creating posts'

param :form, 'post[name]', :string, :required, 'name'

param :form, 'post[publish]', :boolean, :required, 'publish'


swagger_api :index do

summary 'Get all the posts'

notes 'Should be used for fetching all posts'

param :header, :Authoraization, :string, :required, 'Authoraization'

response :unauthorized

response :ok, "Success"


swagger_api :show do

summary 'Get all the posts'

notes 'Should be used for fetching a post'

param :path, :id, :string, :id

response :unauthorized

response :ok, "Success"


swagger_api :destroy do

summary 'Destroy the post'

notes 'Should be used for destroying a post'

param :path, :id, :string, :id

response :unauthorized

response :ok, "Success"





Read More From Here http://goo.gl/dMVHon

September 23, 2016 - (v3.2.3 - v4.0.2)
0 thanks

Usage of SQL and NoSQL Databases in single rails application(MySQL, PostgreSQL and MongoDB)

There are distinctive reasons why you should think about having various databases in your Ruby on Rails application. In my situation, I expected to store large quantities of data.

Consider default database is MySQL. In our application database.yml file write connections for MySQL in normal way. After that, for connecting postgresql in the same application we need to create custom files.

Create the custom database files to connect postgresql

We’re going to set up a second database called “Stats”

First of all, create the file config/database_stats.yml and populate it as you do with the primary database’s config file.

Your file will look something like this:

adapter: postgresql
encoding: utf8
reconnect: false
database: db_info_development
pool: 5
host: localhost
username: postgres

We’re now going to create a directory that will hold the schema and all the migrations of the Stats database.

Create directory with name db_stats in the rails root and copy the structure as mentioned below


The created files should be empty.

Add Rake Tasks

For handling stats database, we need to write custom tasks for creation, migrations and other functionalities.

Create a file lib/tasks/db_stats.rake with the below content

namespace :stats do

namespace :db do |ns|

task :drop do

task :create do

task :setup do

task :migrate do

task :rollback do

task :seed do

task :version do

namespace :schema do
task :load do

task :dump do

namespace :test do
task :prepare do

# append and prepend proper tasks to all the tasks as defined above

ns.tasks.each do |task|
task.enhance [“stats:set_custom_config”] do

task :set_custom_config do

# save current vars

@original_config = {
env_schema: ENV[‘SCHEMA’],
config: Rails.application.config.dup

# set config variables for custom database

ENV[‘SCHEMA’] =db_stats/schema.rb”
Rails.application.config.paths[‘db’] = [“db_stats”]
Rails.application.config.paths[‘db/migrate’] = [“db_stats/migrate”]
Rails.application.config.paths[‘db/seeds’] = [“db_stats/seeds.rb”]
Rails.application.config.paths[‘config/database’] = [“config/database_stats.yml”]

task :revert_to_original_config do
# reset config variables to original values
ENV[‘SCHEMA’] = @original_config[:env_schema]
Rails.application.config = @original_config[:config]

Once all of this setup is done, we can create the stats database and run its first migration:

$ rake stats:db:create
$ rake stats:db:migrate

This will generate the Stats database schema file in db_stats/schema.rb.

Add a custom migration generator We cannot use rails generator because the path hardcodes the db/migrate. Read more From Here http://goo.gl/jVCVRJ

September 13, 2016 - (v3.2.1 - v4.2.7)
0 thanks

Search Kick Gem – To Make Your Search Intelligent On Rails App

Search kick Gem is a Ruby gem that runs on top of Elasticsearch and makes it easy to make searches in a Rails-friendly fashion. In addition, it allows you to add more features including analytics, autocomplete, and personalized results. Searchkick realizes what your users are searching for. As more individuals hunt, it gets more brilliant and the outcomes improve. It’s benevolent for designers – and supernatural for your users. It handles stemming, special characters, extra whitespace, misspellings, custom synonyms. To get started, make sure that you have Elasticsearch installed on your home computer. Depending on your operating system, the installation process is slightly different and make sure you have at least Java 7. Once you have that done, add and install searchick to your Rails application by adding the following to your Gemfile and running bundle install.


When you have both installed and ready to go, you need to indicate which models you might want to be able to search through in your application. Just add searchkick to the model file to make it work. Then, we need to reindex the models so that Elasticsearch can run properly. In your terminal, run:

rake searchkick:reindex:all

Seeking with searchkick is entirely straightforward. Basically run YourModel.search, trailed by the parameters of the search and any filters that you want to add on. For instance, one of more complex searches is below:

 @offers = Offer.search params[:search],
 page: params[:page], per_page: 10,
 order: {starttime: :desc},
 fields: [{offer_name: :word_start}, 
offer_request_name: :word_start}:price],
 where: {
 starttime: {
 gte: DateTime.strptime(params[:fromdate],‘%m/%d%Y’),
 lte: DateTime.strptime(params[:todate],‘%m/%d/%)

In this search, we take the search query of the user with params[:search], and look through of the lessons with the following conditions:

Read More From Here : http://www.railscarma.com/blog/technical-articles/search-kick-gem-to-make-your-search-intelligent-on-rails-app/

September 1, 2016
0 thanks

Previewing Emails in Rails Applications With the Mail_View Gem

Sending an email from an application through a development or staging environment can be cumbersome especially when you want to preview the mail before you hit the send button. With the gem ‘mail_view, you can easily preview emails right from your development environment. Previewing mail is important to ensure that you are sending the right email and to the right person.

Never send a mail in dark anymore with the ‘mail_view gem! Check out more below on how it can be implemented in your application during the development stage.

Rails Email Preview helps us to quickly view the email in web browser in development mode.

  1. Add “gem ‘rails_email_preview’, ‘~> 0.2.29’ “ to gem file and bundle install.

  2. Run “rails g rails_email_preview:install” this creates initializer in config folder and add routes.

  3. Run “rails g rails_email_preview:update_previews” this crates mailer_previews folder in app directory.

Generator will add a stub to each of your emails, then u populate the stub with mock data.


class UserMailerPreview
def invitation
UserMailer.invitation mock_user(‘Alice’), mock_user(‘Bob’)

def welcome
UserMailer.welcome mock_user

def mock_user(name =Bill Gates’)
fake_id User.new(name: name, email:user#{rand 100}@test.com”)

def fake_id(obj)
obj.define_singleton_method(:id) { 123 + rand(100) }
  1. Parameters in search query will be available as an instance variable to preview class.

Ex: if we have a URL like “/emails/user_mailer_preview-welcome?user_id=1” @user_id is defined in welcome method of UserMailerPreview it helps us to send mail to specific user.

class UserMailerPreview
def welcome
user = @user_id ? User.find(@user_id) : mock_user
  1. To access REP url’s like this

  2. We can send emails via REP, this will use environment mailer settings. Uncomment this line in the initializer to disable sending mail in test environment.

    config.enable_send_email = false

References :

  1. github.com/glebm/rails_email_preview

  2. richonrails.com/articles/action-mailer-previews-in-ruby-on-rails-4-1

Read More From Here>>> http://goo.gl/KQBk5S

August 21, 2016
1 thank

Integrate enum with PostgreSQL Enumerated Types

Extract from:


There are 2 things that we need to do before we can use ActiveRecord::Enum with PostgreSQL Enumerated Types: database migration and enum declaration.

First, let’s create the database migration:

$ bundle exec rails generate migration AddGenderToUsers gender:gender

Next, edit the generated migration to add the type:

# db/migrate/20150619131527_add_gender_to_users.rb
class AddGenderToUsers < ActiveRecord::Migration
  def up
    execute <<-SQL
      CREATE TYPE gender AS ENUM ('male', 'female', 'not_sure', 'prefer_not_to_disclose');

    add_column :users, :gender, :gender, index: true

  def down
    remove_column :users, :gender

    execute <<-SQL
      DROP TYPE gender;

Once you’re finished with that, run the migration:

$ bundle exec rake db:migrate

Now, we have completed the database migration. The next step is to declare an enum in the User model. Earlier, we used both the Array and Hash forms to declare an enum. For the integration to work, we need to declare an enum using the Hash form:

# app/models/user.rb
class User < ActiveRecord::Base
  enum gender: {
    male:                   'male',
    female:                 'female',
    not_sure:               'not_sure',
    prefer_not_to_disclose: 'prefer_not_to_disclose'

Finally, we can store ActiveRecord::Enum values using PostgreSQL Enumerated Types. As a bonus, all helper methods provided by ActiveRecord::Enum still work as expected.

August 18, 2016
0 thanks

Top 10 Tools/Ruby Gems for Quickly Building Social Networking Sites

The world is social. Where art thou? In the attention-drive world, social media rules the roost. So, it is no wonder if you have been bitten by the social networking bug and want to develop a social networking site. If you are contemplating the best platform for developing a social media site, then Ruby on Rails is an ideal option. Not only, Ruby on Rails offer you rapid development, it comes packed with a horde of gems to make the work even easier. Check out some of the best Ruby gems for building social networking websites:

Read It From Here: http://goo.gl/3OVVQY

July 25, 2016
0 thanks

Application Performance Monitoring with New Relic

The New Relic Ruby Agent runs in one of two modes:

Production Mode Low overhead instrumentation that captures detailed information on your application running in production and transmits them to newrelic.com where you can monitor them in real time.

Developer Mode

A Rack middleware that maps /newrelic to an application for showing detailed performance metrics on a page by page basis. Installed automatically in Rails applications.

NewRelic Setup

To add ruby-agent to your project add the gem in your gemfile


Create an account in newrelic.com. You will get a 30 day free trial version

Once you signup download newrelic.yml file

Copy and paste the file in your project config folder



Bundle install (after adding gem into gemfile)

Rails 2.x without bundler

config.gemnewrelic_rpm” (In environment.rb)

After installation of newrelic go to the newrelic.yml and look into it by default you will get

Development, test, staging and production environments

You can change/add the environment name like staging can change it to uat.

You can find developer_mode only for development environment, so what is developer_mode?


New Relic Agent will present performance information on the last 100 transactions you have executed since starting the mongrel

NOTE: There is substantial overhead when running in developer mode (Do not use for production or load testing.)

To view the performance information including SQL statement

localhost:3000/newrelic (If your application is running in port 3000)

Set the application name for your required environment, so that the application name will be appearing on your newrelic dashboard and it will be easy to monitor without the name ambiguity

For example:


<<: *default_settings

monitor_mode: true

app_name: Sample_Project

So when you open NewRelic dashboard you can find Sample_Project under Name column, click on it to see all the transactions.

Advantage of NewRelic Monitoring:

The main advantage of newrelic is Application Performance Management (APM).
New Relic APM is the only tool you’ll need to see everything in your Ruby application from the end user experience to server monitoring. Trace slow database queries, 3rd party APIs and web services, caching layers, background jobs, and more. Ruby monitoring has never been easier.
Error Rate: the agent collects and reports all uncaught exceptions by default.
Transaction history with graphs.
SQL Query in Transaction block.
You can also find most time consuming methods, what is making it slow.
You can also trace background-jobs.
Every time you’re working on the performance of your application, it’s always good to know what kind of effect does a particular deploy has on the performance of the application. To understand the effect, you can notify New Relic when you are performing a deployment. This way if performance degrades or improves by setting key transactions, you will get to know and then measures could be taken to improve the performance.

Newrelic is a complete tool to monitor your application and quickly response on the errors and help in serving end users in an optimized way. http://www.railscarma.com/blog/technical-articles/application-performance-monitoring-with-new-relic/

July 19, 2016 - (v4.2.1)
0 thanks

A Detailed Look at Rails 5 Features and Changes

Rails 5 was announced by David Heinemeier Hansson(DHH), creator of Ruby on Rails Framework at RailsConf 2015 in Atlanta. Ruby 5.0.0 Beta version was released on 18th December 2015. Apart from the Rails 4, the new features are implemented in 5 version such as Action cable and improved turbolinks that can instantly improve the web development workflow. Here are the Rails 5 Features : Ruby Version Support :

Rails 5 will only work on Ruby 2.2.1 and above. The following features are the reasons for using ruby 2 or higher :

Symbol Garbage Collector

In Ruby On Rails applications, we usually pass symbols all over the place, doing this opens the possibility of DoS attacks when our memory is consumed by symbols that never get garbage collected. Ruby 2.2.0 introduced changes in its garbage collector to be able to collect symbols.

Module #prepend

Allows to do insert a module in-front of the class it was prepended.

Keyword Arguments

Ruby 2.0 introduced first-class support for keyword arguments:

def foo(bar:default’)
puts bar

foo # => ‘default’
foo(bar:baz’) # => ‘baz’
Incremental GC

This will help to reduce memory consumption by Rails applications. Deprecated code removed and Cleanup

Action Mailer

#deliver and #deliver! methods have been removed, use new methods deliver_now or deliver_later.

*_path helper in email views has been removed and use *_url.

Active Record

Protected attributes(attr_accessible) completely unsupported now.

Unsupport for activerecord-deprecated_finders gem.

ActionPack Assertions

assert_template and assigns() assertions are deprecated and moved into its own gem rails-controller-testing.


Rails 5 has introduced has_secure_token to include random token in models.

Action View

In action view, helper methods such as content_tag_for and div_for were removed from the core and moved out to a separate gem record-tag-helper.


New Turbolinks 3 solves one of the major problems of Rails. Few web apps works really slow cause it reloads the full page from server. This new Turbolinks 3 reloads only the contents of the body, it doesn’t reloads the whole page. It allows you to specify which elements to replace through partials.

Partial replacement feature, is the one of the most significant change in Rails 5. We will be able tell Turbolinks from client side that what content do we need to change/replace and what we don’t. To decide the replacement strategy in DOM, turbolinks will look for HTML5 custom attributes data-turbolinks-permanent and data-turbolinks-temporary.

We can use turbolinks.visit or Turbolinks.replace to update DOM and to trigger a replacement in the client side. Visit will issue a GET to the server to obtain the HTML that must be used to replace our DOM and replace expects from us the HTML that should be used for its operation.

The same functionalities can be triggered from the server-side with redirect_to and render, both redirect_to and render can receive change, keep and flush as options. But redirect_to can also receive turbolinks with true or false to force a redirect.

Action Cable

Action Cable is a framework, used to extend Rails via Websockets to add real-time message passing functionality. This is probably one of the best things in Rails 5. It smoothly integrates WebSockets with the rest of Rails application. Action cable makes it very easy to add realtime features to your app. The reason behind adding this feature was increasing need for such feature. It was introduced to extend Rails functionality with real time messaging utilizing WebSockets.

Action Cable offers a lot of advantages including being an open connection, extremely lightweight compared to other HTTP request. Another advantage is that once a connection made, it will remain open. Through that open line, both server and the client can communicate without reestablishing a new connection. The server and the client can use full-duplex connection of WebSocket to communicate to each other at the same time.

One disadvantage of Action Cable is its inability to cache requests. Another con of WebSocket is the support among browsers as only 70% of the browser market allows for WebSocket connections.

Additional New Features in Rails 5

#or method in ActiveRecord::Relation
#belongs_to is required by default
Active Record Attribute API
has_secure_token landed in ActiveRecord
Mysql active record adapter gets Json support
Render a template outside the controller
Better Minitest Test Runner

Rails API

It allows you to generate API – only Rails app and cleans out all the middleware which is not necessary in an app. When you create a new Rails application using new rails API, you will get the configuration which assumes you are working with JSON not with HTML.

Command to Create Rails API Application:

rails new my-app-apiapi

Render From Anywhere

All these days we have been using gems like render_anywhere to render views outside of controller. In Rails 5 you can render your views from anywhere. Along with the rendering options, there is also an option available for passing instant variables to templates.

Restart your App with a Rake Command

In Rail 5, you can restart all your apps with the command rake restart. And for migration: rails db:migrate Note that this list is not conclusive and to know more about all the changes in Rails 5, we recommend you to check out the release announcement on Rails.Org.

July 13, 2016
0 thanks

How to translate JavaScript strings in Rails

Rails I18n and elegant message passing to JavaScript

The process of “internationalization” usually means to abstract all strings and other locale specific bits (such as date or currency formats) out of your application. The process of “localization” means to provide translations and localized formats for these bits. How I18n in Ruby on Rails Works

❝The limits of my language are the limits of my world.❞ ‒Ludwig Wittgenstein. With over 6,909 distinct languages in the world and most of them differing in so many different ways (e.g. in pluralization rules), it is difficult to provide specific tools for internalization. However, for unrestricted barriers of languages, Rails I18n API focuses on:

providing support for English and similar languages out of the box
making it easy to customize and extend everything for other languages

As part of this solution, every static string in the Rails framework – e.g. Active Record validation messages, time and date formats – has been internationalized, so localization of a Rails application means “over-riding” these defaults.

1.1 The Overall Architecture of the Library

Thus, the Ruby I18n gem is split into two parts:

The public API of the i18n frameworka Ruby module with public methods that define how the library works
A default backend (which is intentionally named Simple backend) that implements these methods

As a user you should always only access the public methods on the I18n module, but it is useful to know about the capabilities of the backend.

Here, the simplest way to implement internationalization in JavaScript;

a) Use the Script

<script type=”text/javascript”>
window.I18n = <%= I18n.backend.send(:translations).to_json.html_safe %>

b) You can add the below code in JS file;


c) Get help from the application helper by adding the below method;

def current_translations

@translations ||= I18n.backend.send(:translations)



d) The backend needs to be initialized if it hasn’t been already.

I18n.backend.send(:init_translations) unless I18n.backend.initialized?

# now you can safely dump the translations to json

e) Invoke the below in your application.html.erb ;

<script type=”text/javascript”>

window.I18n = <%= current_translations.to_json.html_safe %>


f) To avoid having to know the current locale in JavaScript.

I18n[“alpha”][“welcome”]; Or I18n.alpha.welcome;

g) Various libraries and plugins for Internationalization & localisation:

i18next – http://github.com/i18next/i18next

I18n gem – http://github.com/svenfuchs/i18n

requirejs-i18n – http://requirejs.org/docs/api.html#i18n

Read More :http://www.railscarma.com/blog/technical-articles/how-to-translate-javascript-strings-rails/

July 12, 2016
0 thanks

Ruby on Rails vs PHP

With more and more applications being built every day, programming languages too are becoming generic and all-purpose. Every programming language comes with its own set of specialization, and comparison between one programming languages to others may seem like a comparison between apples and oranges. However, comparison between two programming languages may offer you insights that might be crucial in your decision to go for a specific programming languages, especially when it comes to Ruby on Rails vs PHP. Since at RailsCarma, we work with both the ecosystems, we are able to understand the advantages and disadvantages of both. Here are some very simple and easy to understand comparison between Ruby on Rails and PHP.

PHP: PHP is a scripting language, used for web development to make interactive pages. The most common frameworks used for PHP are CakePHP, CodeIgnitor, Laravel, etc.

Ruby on Rails: Ruby is a scripting language and Rails is a web application framework written in Ruby.

  1. To Learn

PHP is simpler to learn as compared to Ruby especially for fresher in development. PHP codes can be easily run on server and deployed. To maintain the code, some standard needs to be followed. When it comes to frameworks, the benefit of PHP is that, it has more number of frameworks compared to Ruby. You can find more PHP developers compared to Ruby on Rails, which is really helpful for the companies or developers who need to learn the language. Documents and solutions are easily and readily available for PHP than Ruby on Rails, as applications and websites developed in PHP are more in number as compared to RoR.

  1. Resources

PHP provides lots of resources, frameworks and applications, such as WordPress, Drupal, Joomla, Magento, whereas Ruby on Rails in this department.

  1. Performance

PHP (language) is faster as compared to Ruby on Rails (framework) as it was designed only for web, but PHP is almost same or slower when it’s with frameworks like Laravel, CodeIgnitor, etc.

  1. Frameworks

Rails – The more you work on this framework, the more you will gain. It helps in providing quality products in less time when compared to PHP. Rails is a stable framework so companies and developers can easily adjust to it by learning one single framework, whereas for PHP there are a lot of frameworks which may make learning confusion. There are also no surety whether all the PHP frameworks will be supported in future or not.

  1. Development

Rails is a well-engineered framework where most of the necessary things are automated so that developer can just focus on business related work.

The points where PHP lacks are:

ScaffoldingGenerating a code in an easy and straightforward way, helps in faster development, whereas PHP lacks in this regard. However, PHP community has started work on this with FuelPHP providing similar features.
GemsRails provides plugins as a gem. Just add in your application and it fastens your development. Also, it’s easy to maintain as you are not trying to load libraries. For ex:Devise” gem which is used for authentication can be just installed in an application to handle all the processes.
ORMActiveRecord in the Ruby on Rails is the best part where you can perform all the database related queries using Ruby. Although PHP frameworks too provide the same but not up to the level of Ruby on Rails.
  1. Testing

Rails has testing frameworks that can be used to test your code and provide bug free code and make the client happy, where PHP framework are still trying to get this feature. PHPUnit is one such example.

  1. Cost

Development in PHP is much cheaper as compared to development in Ruby on Rails. Since, PHP is easier to learn and implement, it has more developers and so because of resources vs demand scale, it is cheaper to get your website developed in PHP as compared to Ruby on Rails.

Conclusion PHP has very large developer pool, it is easy to learn, has too many framework to choose, can find easy solution with the availability of experienced developers and is affordable. Ruby on Rails has passionate community, is always introducing new changes, application will be quick to market and best suits for agile development.

June 8, 2016
0 thanks


There are basically two levels of accessing network services in case of rails .

The socket and network libraries are such important parts of integrating Ruby applications with the Internet and other communications-based environments.

One is through socket libraries provide low level access to connection oriented and connection-less protocols. Where user can implement client and server connection. Ruby is also having Network libraries that provide users a high level access to specific network protocols like FTP,HTTP and Etc.

At a low level, you can access the basic socket support in the underlying operating system, which allows you to implement clients and servers for both connection-oriented and connectionless protocols. Ruby also has libraries that provide higher-level access to specific application-level network protocols, such as FTP, HTTP, and so on.

What are Sockets?

Sockets are basically a bidirectional communications channel. Sockets may communicate within a process, between processes on the same machine, or between processes on different continents. Sockets can be implemented on different channels : Unix domain sockets, TCP, UDP, and so on. The socket library mainly provides specific classes and interface for handling a transports.

A SimpleClient:

Hereis a very basic client program which will open up a connection to a given port and given host. Ruby class TCPSocket provides open function to open a socket. The TCPSocket.open(hosname, port ) opens a TCP connection to hostname & theport.

Once socket is open, you can actually read that particular thing like IO object. When it’s done, just remember to close it, as you close that file. The following code connects to a given host and port, reads any available data from the socket, and then exits:

require ‘socket’ # Socket in standard library

hostname = ‘localhost’

port = 8080

s = TCPSocket.open(hostname, port)

while line = s.gets # Gets and Read the lines from the socket

puts line.chop # And print with platform line terminator end

s.close # socket Closed

A Simple Server: To write Internet servers, we basically use this TCPServer class. A TCPServer object is a factory for TCPSocket objects. Now call TCPServer.open(hostname, port function to specify a port for your service and create a TCPServer object. Next, call the accept method of the returned TCPServer object. This particular method waits till client connects to the port you specified above, and then returns a TCPSocket object that basically represents the connection to that client.

require ‘socket’ # Get sockets from stdlib server = TCPServer.open(8080) # Socket to listen on port 8080 loop { # Servers run forever

client = server.accept       # Wait for a client to connect
client.puts(Time.now.ctime)  # Send the time to the client
client.puts "Closing the connection. Bye!"
client.close                 # Disconnect from the client


Now run this server in background and then run above client to see the result.

June 7, 2016
0 thanks

foreign_key option

It is also possible to specify that add_foreign_key should be added to the schema:

add_reference(:products, :supplier, foreign_key: true)
May 25, 2016
0 thanks

Active Record Import

With activerecord-import, you’d just add your records to an array and call import:

records_to_import = pricing_data.map do |location, price|
  Inventory.new(location: location, price: price) 

Inventory.import records_to_import 
May 25, 2016
0 thanks
May 25, 2016 - (v1.0.0 - v3.1.0)
0 thanks