Tag: Ruby on Rails application development

Why Ruby on Rails is Popular among Developers and Entrepreneurs?

Posted on by Jay

Not so long, just ten years ago, the Rails framework was written in Ruby programming language.

According to Hotframework ranking statistics, “Rails reside in the 4th place at the overall catalog of frameworks used now-a-days”.

Ruby on Rails Ranking on HotframeworksSource: Hotframeworks.com

GitHub warehouse, StackOverflow query and questions, and Google Trends all are displaying the same statistics.

Overall Framework Catalog Ranking
Overall Framework RankingSource: Hotframeworks.com

So, the first question arises, why this Ruby on Rails is so popular between both developers and entrepreneurs?

Many merchandise owners think Ruby web development is the most prolific way to build web applications. Well, it’s not an uncovered claim. It permits efficient ways for structuring applications at every step of the development procedure when many significant mechanisms can be generated as an alternative to being coded.

Never miss an update for us. Join 10,000+ marketers and leaders.

Ruby on Rails includes many established techniques and methods, familiar by both beginners and experienced developers, to deliver high-quality software. So, it would be easier to maintain the code in the future even, the addition of new features and making other changes would be like a piece of cake also.

First let’s see, how it works?

Well, Ruby development works for countless projects; however, it is an ideal option if your site or app refers to one of the mentioned classes:

  • E-commerce: Ruby on Rails offers significant forms with very familiar user-friendly feature and modular based approach for most e-commerce sites.
  • Content Management: Ruby web development would be the perfect choice for those websites which exhibit lots of database-friendly content such as the article, audio, video etc. It gives the easiest navigation to the site, upload and manages content as well.
  • Custom Database Solutions: ROR works perfectly at higher database configuration for different business models.
  • Membership Sites: Rails is good for subscription sites, membership site and social networking enabled sites. It has a number of plug-ins, which helps resolve approximately any job of social networking.

Sites like Shopify, Hulu, Groupon, Twitter, ZenDesk, YellowPages, and GitHub has developed with Ruby on Rails.

Here at Andolasoft, we also have vast experience in building projects on Ruby on Rails. Below are only a few examples:

Portfolio for Ruby on Rails Projects

Now come to the main query, Why Ruby on Rails is so popular?

Ruby on Rails’ reputation between developers and business owners has risen rapidly. Let’s find out some reasons.

1. Ruby is an ideal answer for MVP development

Development of Minimum Viable Product (MVP) to authenticate the thought with a user base is the baseline for a startup approach. Startups’ software development procedure is often limited by time and budget. So, it is essential to find the development team who would run programming tools. Below I have tried to explain a few reasons why it is good for building an MVP.

  • Fast programming: The tempo of MVP development in Ruby is much advanced in contrast with that incomparable language such as PHP or Python. When you’re into startup you always need to manufacture products as fast as possible. Ruby with its built-in development tools and handy elements allows you to speed up the development procedure and focus on your core business.
  • Strong Ecosystem and Higher Compatibility. Ruby on Rails having an enormous set of features such as multi-platform compatibility, object-oriented, bunch of free plugins (gems) and best compatibility with other frameworks.
  • Save on development costs: Rails’ machinery significantly clips the financial plan of the project, which is particularly precious for startups. Also, RoR does not involve any costs if you want to re-use, change, duplicate and allocate it.
  • Easy to scale: Startups get hold of a working model inside a short time without spending much funds. This model may develop into a complete application with fewer efforts.

2. Easy API Formation for Mobile Apps

Application developed with Ruby on Rails uses RESTful structural design by default. It allows APIs creation easier and it is a well-recognized model among mobile and web programmers as well. You do not require hiring a new developer to implement RESTful code either.

3. Ruby is perfect for agile projects

RoR’s modular design helps to reproduce the instant changes rapidly with no loss in code and quality. Product proprietor is also able to give immediate feedback, and new versions can be implemented instantly. Automated tests in Rails structure help make sure the lack of bugs throughout code adjustment and it does not require extra documentation.

4. Community support

Community support for Ruby on Rails is just amazing – Ruby developers can get free online tutorials. The Ruby developer community forever keeps the framework advanced.

5. Automation and Development Smoothness

This is part where developers love Ruby on Rails. The framework automates many manual odds so that developers can put their focus on the project’s core features. It makes sure the immense efficiency of development procedure where the product proprietors get impressed.

I’ve worked with the team at AndolaSoft on multiple websites. They are professional, responsive, & easy to work with. I’ve had great experiences & would recommend their services to anyone.

Ruthie Miller, Sr. Mktg. Specialist

Salesforce, Houston, Texas

LEARN MORE

Last but not least, the framework offers economical, quick and dependable testing, which create it a charming spot for developers.

In other hands, outstanding maintain and automated structure of Ruby on Rails are the main reasons why it is so demand able.

Now that you know, what is Ruby on Rails used for and why it is popular for many developers and gainful for an extensive range of entrepreneurs. We could say it is one of our favorite development tools. In the end, Ruby on Rails outsources permits you to get a project within less period of time without giving up quality and performance of your application or website.

Are you planning to build your dream project on Ruby on Rails? Let’s Discuss!

3 Ways To Keep Your Ruby On Rails Apps Healthy

Posted on by Jay

Ruby on Rails is an enormous framework for developing contemporary web applications and because of this, it is highly essential to make sure your apps are always running smooth plus healthy.

The world is moving very fast and custom application developers are playing with different types of technologies for creative and user-friendly application development.

Therefore, application development is not a big challenge for developers or for solution providers but choosing the right technology – does matter a lot.

Selecting the right technology-solution for your application completely depends upon you and your technical consultant. They help you in selecting the right one and how that will help to keep your application healthy for long-term future use.

Discover essential strategies to uphold the health and vitality of your Ruby on Rails applications with guidance from Andolasoft, a leading software development company.

In this comprehensive guide, you’ll uncover a range of actionable best practices designed to ensure the ongoing well-being of your Ruby on Rails apps.

Never miss an update from us. Join 10,000+ marketers and leaders.

That brings me to tell you about Ruby on rails is the great framework, which supports agile development.

Ruby on Rails is both revolutionary as a language as well as a framework.

Klaus-Michael Vogelberg, CTO of Sage Software

Rails is the most well thought-out web development framework I’ve ever used. And that’s in a decade of doing web applications for a living. I’ve built my own frameworks, helped develop the Servlet API, and have created more than a few web servers from scratch. Nobody has done it like this before.

James Duncan Davidson, creator of the Tomcat web server

A supportive and user-friendly web application is always preferable by customers. And keeping the application smooth and healthy in factors like; slow pages, memory, security, third party APIs and server’s resources are always the first thing in precedence that will keep you one-step ahead of your competitors.

Let us discuss the key points, which will keep your ruby on rails application smooth and healthy for all time;

1. Keep Your Code Clean:

Application coding must be clean and bug free. Duplicated blocks of code, or several levels of nested conditions creates bugs in the application.

You need to check the code smells (the deeper problems of your application in the code part) of application. Code smells are dangerous problem for application. Solutions for code smells reduces the risk of application and makes it easier for ruby on rails developer to modify and maintain it once the application is ready.

To know the bad practices and code smells of your application, you can use one of the useful tool we use known as: RubyCritic.

Andolasoft’s Expert Tip: You can use the below Gemfile for easy installation of RubyCritic.

[code language=”php”]
# Gemfile

gem ‘rubycritic’, require: false, groups: [:development, :test]
[/code]

Once that’s done, just bundle install and run RubyCritic against your app’s code:

[code language=”php”]
$ cd /path/to/your/app

$ bundle install

$ bundle exec rubycritic –format html
[/code]

After some time RubyCritic will generate the report of your application code quality and if that report will not open automatically, you need to collect that from your app’s tmp/rubycritic folder.

[code language=”php”]
$ open tmp/rubycritic/overview.html
[/code]

2. Security Check Up:

Rails have many security options for any type of security issues.

Brakeman is the tool through which you can easily check your applications security issues. Let us have a quick look at the installation processes of brakeman like a gem.

Jump into your app’s code and run the brakeman command:

[code language=”php”]
$ cd /path/to/your/app

$ gem  install brakeman

$ brakeman
[/code]

After that brakeman will generate a complete report with all your security issues (if any) – that will help you to resolve those issues quickly.

3. Set Up Monitoring

Once your application comes out of the development process, you need to very carefully check each part of it, so that nothing goes wrong for the end-users.

I’ve worked with the team at Andolasoft on multiple websites. They are professional, responsive, & easy to work with. I’ve had great experiences & would recommend their services to anyone.

Ruthie Miller, Sr. Mktg. Specialist

Salesforce, Houston, Texas

LEARN MORE

There is always a slip between the ‘cup-and-the-lip’, and this tells us to be prepared for any possibilities of errors. Free tools like StatusCake, Sentry and Rollbar can be used to check for error while getting reports on the same whereas Skylight and New Relic for performance monitoring of your application.

The Final Tale

Keeping your productive Ruby on rails application healthy is an ongoing process. Consultation with specialized and experienced ruby on rails developers is much needed to stay away from those uncanny and strange surprising issues.

Got a Ruby on Rails App or Idea to discuss about? Consult Now

4 Simple Steps To Implement “Delayed Job” In Rails

Posted on by Jay

Here in this article, I going to tell you the best way to implement “delayed job” in rails

“delayed_job” is a ruby gem used to execute tasks as a background process in Rails environment, increasing page rendering speed.

Delayed::Job (or DJ) allows you to move jobs into the background for asynchronous processing.

Why you need a background process and is it really that important!

Let’s consider a scenario where a mailing application needs to send emails to a huge list of recipients. In such cases it is obvious that the processing time is too long, annoying the users.

Here are some of key points to consider:

  • Incredibly quick & easy to get rolling
  • No addition to your “stack”, runs just fine with Active Record
  • Good choice for beginners while migrating code from foreground to the background

Hence, it’s only wise to move the long running tasks as a background process by using “delayed_job” gem.

Detailed steps to integrate delayed job in a Rails application

Step# 1

  • Add gem to the Gemfile
  • “delayed_job” supports multiple back-ends for storing the job queue
  • To use “delayed_job” with Active Record, use gem ‘delayed_job_active_record’
  • To use “delayed_job” with Mongoid, use gem ‘delayed_job_mongoid’

Example

/Gemfile.rb

  • gem ‘delayed_job_active_record’, ‘4.0.3’
  • Run “bundle install” to install the “delayed_job” gem

Step# 2

  • Generate the related file for the Job run
  • Generate related files required to run the background job by running the following command
    • rails g delayed_job:active_record

It adds following files to the application

  • A Script named “delayed_job” inside “/bin” folder to run the jobs which are in queue.
  • Migration file to create a table to store the job with other information such as priority, attempts, handler, last_error, run_at, locked_at, failed_at, locked_by, queue.

Run the migration file by using the following command

  • rails db:migrate

Set the queue_adapter in config/application.rb

  • config.active_job.queue_adapter = :delayed_job

If you are using the protected_attributes gem, it must appear before delayed_job in your gemfile. If your jobs are failing with:

  • Setup Delayed::Job config in an initializer (config/initializers/delayed_job_config.rb)
    • Delayed::Worker.destroy_failed_jobs = false
    • Delayed::Worker.sleep_delay = 60
    • Delayed::Worker.max_attempts = 3
    • Delayed::Worker.max_run_time = 5.minutes
    • Delayed::Worker.read_ahead = 10
    • Delayed::Worker.default_queue_name = ‘default’
    • Delayed::Worker.delay_jobs = !Rails.env.test?
    • Delayed::Worker.raise_signal_exceptions = :term
    • Delayed::Worker.logger = Logger.new(File.join(Rails.root, ‘log’, ‘delayed_job.log’))

Step# 3

  • Replace script/delayed_job with bin/delayed_job
  • Start up the jobs process

There are two ways to do this.

  • If application is in development mode, we would use the below rake task instead.
    • rake jobs:work
  • If application is in production mode, then it is preferred to use the “delayed_job” script. This demonizes the job process and allows multiple background processes to be spawned.

To use this, pursue the following steps

  • Add gem “daemons” to your Gemfile
  • Run bundle install
  • Make sure you’ve run rails generate delayed_job
  • If you want to just run all available jobs and exit you can use rake jobs:workoff
  • Work off queues by setting the QUEUE or QUEUES environment variable.
    • QUEUE=tracking rake jobs:work
    • QUEUES=mailers,tasks rake jobs:work

Step# 4

  • Add task to run in background
  • In Controller just call .delay.method(params) on any object and it will be processed in the background.

Example:

UsersController before adding to background job

[code language=”html”]
class UsersController < ApplicationController
def send_email
User.find_each(is_subscribed: true) do |user|
NewsMailer.newsletter_mail(user).deliver
flash[:notice] = "Mail delivered"
redirect_to root_path
end
end
end
[/code]

 
UsersController after adding to background job

[code language=”html”]
class UsersController < ApplicationController
def send_email
User.find_each(is_subscribed: true) do |user|
# add .delay method to add it to background process. In case of mail sending remove the .deliver method to make it work.
NewsMailer.delay.newsletter_mail(user)
flash[:notice] = "Mail delivered"
redirect_to root_path
end
end
end
[/code]

Advantages of implementing above steps:

  • No more waiting for a response, after clicking a link to do a big stuff.
  • Just call .delay.method(params) on any object and it processes in the background.
  • Job objects are serialized to yaml and stored in the delayed_jobs table, so they can be restored by the job runner later.
  • It automatically retries on failure. If a method throws an exception it’s caught and the method reruns later. The method retries up to 25 times at increasingly longer intervals until it passes.
  • “delayed_job” gem maintains log by creating a log file “/log/delayed_job.log”

I am sure this article will give you a clear idea about the way to implement “delayed job” in rails. You can share your thoughts with comments if I have missed anything or if you want to know more.

Do you work on or use Ruby on Rails? Let’s Discuss!

File Uploading Through Paperclip in Rails 3.x

Posted on by Jay

Rails3Paperclip is an easy file attachment library for Rails Applications. Attached files are saved to the file system, database or cloud and referenced in the browser by an easily understandable specification.

Here is an example to explain the image attachment for a user profile in an application. This example narrates about saving the image in the file system. However, the images can be saved in S3 bucket [Amazon Simple Storage Service, S3] or database.

Step#1

ImageMagick must be installed in the system and Paperclip must have access to it. ImageMagick is a software suite to create, edit, compose, or convert bitmap images. It can read and write images in a variety of formats. You can download it by visiting the following URL:

http://www.imagemagick.org/script/index.php

Step#2
Include the paperclip gem in your Gemfile

gem "paperclip"

Then run the bundler to install the gem

bundle install

Step#3
Add the fields for the image processing as below in your migration file

class CreateUsers < ActiveRecord::Migration
def change
create_table :users do |t|
t.string :name
t.string :photo_file_name
t.string :photo_content_type
t.string :photo_file_size
t.timestamps
end
end
end

Then run your migration files

rake db:migrate

Step#4

Modify the user model for cropping and save image in your system folder

has_attached_file :photo, :styles => { :small => "150x150>" },
:url => "/system/:attachment/:id/:style/:basename.:extension",
:path => ":rails_root/public/system/:attachment/:id/:style/:basename.:ex

Here you can specify the file path and the image size as per the requirement.

Step#5
Modify your view file to upload an image

<pre class="plain plain">&lt;%= form_for :user,:url =&gt; {:action =&gt; "create"}, :html =&gt; { :multipart =&gt; true } do |f| %&gt;
&lt;%= f.file_field :photo %&gt;
&lt;% end %&gt;</pre>

Step#6
Write the following code to display the image of a user

<%= image_tag @user.photo.url (:small)%>

Please stay connected with us by subscribing our email.
Also feel free to share your opinions in the comments section below:

How To Implement Event Calendar In Rails App

Posted on by Jay

Event calendar is a way to show multiple, overlapping events across calendar days and rows. This is an interface to add events, edit events, & destroy event. In Rails there is a gem/plugin “event_calendar” to implement it just like Google calendar.

The following steps demonstrate the implementation of event_calendar in both Rails 2.3.x and Rails3.x environment.

Step#1 –

Installing the gem/plugin

  • In rails 2.3.x

Install the required plugin from below path

script/plugin install git://github.com/elevation/event_calendar.git

Generate the necessary static file and example

script/generate event_calendar
  • In rails 3.x

Install the required gems

gem 'event-calendar', :require => 'event_calendar'

Run “bundle install”

You can also use as a Plugin, to install plugin

rails plugin install git://github.com/elevation/event_calendar.git

Generate the necessary static file for the event calendar

rails generate event_calendar

Step#2

Include the necessary style sheet & java-script into your layout/view

<%= stylesheet_link_tag "dialog","fullcalendar","jquery-ui","style" %>
<%= javascript_include_tag "jrails1/fullcalendar.js","jrails1/jquery-
ui.js","jrails1/gcal.js","jrails1/jrails.js","jrails1/jquery.validate.js"%>

Step#3

Create a migration file to add necessary columns as follows

class CreateEvents < ActiveRecord::Migration
def self.up
create_table :events do |t|
t.string :name
t.datetime :start_at
t.datetime :end_at
t.timestamps
end
end
def self.down
drop_table :events
end
end

Step#4

Add the necessary paths to the “config/routes” file

  • In Rails 2.3.x
map.calendar '/calendar/:year/:month', :controller => 'calendar', :action => 'index',
 
:requirements => {:year => /d{4}/, :month => /d{1,2}/}, :year => nil, :month => nil
  • In Rails3.x
match '/calendar(/:year(/:month))' => 'calendar#index', :as => :calendar, :constraints => {:year => /d{4}/, :month => /d{1,2}/}

Step#5

Change the Event model to add the calendar as follows

class Event < ActiveRecord::Base
has_event_calendar
end

Step#6

Modify the Calendar controller as follows

class CalendarController < ApplicationController
def index
@month = (params[:month] || Time.zone.now.month).to_i
@year = (params[:year] || Time.zone.now.year).to_i
@shown_month = Date.civil(@year, @month)
@event_strips = Event.event_strips_for_month(@shown_month)
end
end

Step#7

You can also override the events method in helpers/calendar_helper.rb

module CalendarHelper
def month_link(month_date)
link_to(I18n.localize(month_date, :format => "%B"), {:month => month_date.month, :year => month_date.year})
end
# custom options for this calendar
def event_calendar_options
{
:year => @year,
:month => @month,
:event_strips => @event_strips,
:month_name_text => I18n.localize(@shown_month, :format => "%B %Y"),
:previous_month_text => "<< " + month_link(@shown_month.prev_month),
:next_month_text => month_link(@shown_month.next_month) + " >>"
}
end
def event_calendar
calendar event_calendar_options do |args|
event = args[:event]
%(<a href="/events/#{event.id}" title="#{h(event.name)}">#{h(event.name)}</a>)
end
end
end

Step#8

Add the following code to display the calendar in the view file

<%= event_calendar %>

See Also: Security Checks you must do before Rails App release

I hope it helps you. Planning anything in Ruby on Rails? Get in touch with Andolasoft experts. Feel free to give your valuable feedback.

How To Generate Barcode Using Barby Gem In Rails 2.3.8

Posted on by Jay

A barcode is a series of vertical black lines with white spaces in between. This series of lines and spaces can be read by a device that can decode them. This would be a barcode reader.

In Ruby on Rails there is a gem called “barby” which generates the barcode with various format.

Here is an example to create barcode using barby & Rails 2.3.8.

Step#1

Include the barby gems in your config/environment.rb file

config.gem'barby'
config.gem 'barby-chunky_png'
config.gem 'png''RubyInline'

Install the gems by running the commandrake gems:install. Restart the Rails server.

You might face problem to start the server after the gems installed.Comment out the gems “png” & “RubyInline” in the “config/environment.rb” to get the server started.

Step#2

Create a folder named “Barcodes” to store the barcode images in your “Public” folder.

Step#3

Add the below lines of code in your controller

require'barby'
'barby/outputter/png_outputter'

Step#4

The following method will generate the barcode images and store in the “/public/Barcodes” path. Place this method inside the controller.

The “symbology” is the format in which the barcode will be generated. Default is “Code128B”, If you want to generate in different format you can set the “symbology” according to it.

def generate_barcodes(data) # check to see if we don't already have this barcode image uri = CGI.escape(symbology) + '_' + CGI.escape(data) + '.jpg' fname = RAILS_ROOT + '/public/Barcodes/' + uri #fname = '/var/www/html/arc_cloud/arcdevelopment/' + uri
 
# if the barcode image doesn't already exist then generate and save it
if ! File.exists?(fname)
 
str = 'Barby::'+symbology+'.new("'+data+'")'
 
begin
barcode = eval str
rescue Exception => exc
barcode = Barby::Code128B.new(data) # fall back to Code128 type B
end
 
File.open(fname, 'w') do |f|
f.write barcode.to_jpg
end
 
end
uri
end

Step#5

Following lines of code will call to generate your dynamic barcode
generate_barcodes(@item_id)

Step#6

To show the Barcode images call the following lines of code

<img src="/Barcodes/<%= @job_info.job_number %>.jpg" >