redpanthers.co

CLAWING OUR WAY TO THE TOP OF CLUTCH’S DIRECTORY OF RUBY ON RAILS DEVELOPERS IN INDIA

beta — Sun, 06 Sep 2020 07:00:37 +0000

Ruby is a programming language with a set of incredibly versatile strengths and applications, with the Ruby on Rails framework helping businesses in countless industries develop powerful and interactive web solutions. While Ruby on Rails provides a world of endless possibilities for quality development, most businesses lack the in house talent to tap into this source of innovation. We proudly fill in the skills-gap for firms looking to leverage this powerful framework to develop innovative solutions to a number of challenges.

Through our work developing quality web solutions, we have started to garner some industry recognition. We are excited to share that we have been included on Clutch’s directory of the top Ruby developers in India, thanks to a recent research effort on a wide variety of service industries in India. We outranked more than 100 of our competitors as we started our climb to become a top firm in our field.

The research effort we were the subject of included factors such as marketing presence, previous work, and most importantly, client reviews. We have a rating of 4.8 out of 5 stars thanks to what our clients have shared with us, mostly reviews like this,

“Red Panthers is a team of highly skilled and passionate engineers who strive to solve problems in eloquent ways. They were eager to learn and train their team on how to improve. They knew how to solve some problems, and when tougher problems arose, we all worked together to find solutions that worked well for everyone.” – Founder, Devato Inc

Reviews like this help us identify our strengths, weaknesses, and how we are performing for our clients. We eagerly await whatever else our clients will share with us.

In addition to our presence on Clutch, we are included on their sister-site, The Manifest, as one of the top web developers in India. The Manifest helps firms of all shapes and sizes address a wide array of industry challenges by providing curated insights and advice. Our inclusion on their platform as a top firm is due to a number of factors, namely the quality of our work and our affordability. We are grateful to be listed as a top development team on two different industry resources, and we decided to go for a third. We have joined other expert firms in creating a profile on Visual Objects, a portfolio sharing platform for developers, designers, and other innovators alike.

We are hopeful that our status as a trusted development team will only grow from here, and we are grateful for all of the recognition we have received. Thank you to everyone who played a part in our success, we could not have done this alone, and we cannot wait to see what new challenges you have for us.

Configuring a GitLab CI pipeline for Rails, MongoDB, and Rspec

tony — Mon, 29 Apr 2019 11:28:12 +0000

Gitlab has a free private git repository service and an integrated CI service that can be configured to suit our needs. To know more about setting up Gitlab CI, check out our [blog post](link here)

Including MongoDB in CI build system

Instead of installing and starting MongoDB manually, we can use the Gitlab mongo service. A Gitlab service is just another Docker image that runs during your job and is linked to the main image. The first step is to include the latest MongoDB image to the build system. Add this to your .gitlab-ci.yml

services:
- mongo:latest

Add the MONGODB_URI variable

Add a variables section within .gitlab-ci.yml to set the MONGODB_URI variable.

variables:
MONGODB_URI: mongodb://mongo:27017/test_db

Add config/mongoid.yml ile

Add a file config/mongoid.yml.gitlab with the following contents

test:
  clients:
    default:
      uri: <%= ENV['MONGODB_URI'] %>

Override config/mongoid.yml with config/mongoid.yml.gitlab

We need to override the local test configuration with the above settings specific to CI. Add the following to the before_script section of .gitlab-ci.yml

before_script:
  - cp config/database.yml.gitlab config/database.yml

That’s it fellas, you are all set

Summary

The complete .gitlab-ci.yml

image: starefossen/ruby-node:latest
services:
  - mongo:latest
variables:
  MONGODB_URI: mongodb://mongo:27017/test_db
before_script:
  - RAILS_ENV=test bundle install --jobs $(nproc) "${FLAGS[@]}"
  - cp config/mongoid.yml.gitlab config/mongoid.yml
  - RAILS_ENV=test bundle exec rake db:create db:migrate
test:
  script:
    - bundle exec rspec

the contents of config/mongoid.yml

development:
  clients:
    default:
      database: dev_db
      hosts:
        - localhost:27017
      options:
        read:
          mode: :primary
        max_pool_size: 10
production:
  clients:
    default:
      uri: <%= ENV['MONGODB_URI'] %>
      pool_size: <%= ENV['DB_POOL_SIZE'] %>
test:
  clients:
    default:
      database: test_db
      hosts:
        - localhost:27017
      options:
        read:
          mode: :primary
        max_pool_size: 1

and config/mongoid.yml.gitlab

test:
  clients:
    default:
      uri: <%= ENV['MONGODB_URI'] %>

May you have a green build! :-)]]>

Rails 5.2.0

levi — Mon, 29 Apr 2019 11:28:12 +0000

Cheers everyone, the new Rails 5.2.0 has released. Let’s have a look at the new features and upgrades in it.

It’s been too hard to deal with file uploads in Rails. There’s been a lot of fine plugins available, but it was overdue that we incorporated something right into the framework. Finally, we have one, in the form of Active Storage. This release includes Active Storage, a new framework provided by Rails to make it easier to upload and process files. With this new framework, we’ve solved for the modern approach of uploading files straight to the cloud. Out of the box, there’s support for Amazon’s S3, Google’s Cloud Storage, and Microsoft Azure Cloud File Storage. If you’re dealing with images, you can create variants on the fly. If you’re dealing with videos or PDFs, you can create previews on the fly. And regardless of the type, you can analyze uploads for metadata extraction asynchronously. This framework is not only used in production, but it is born for production.

There’s a sparkling new Redis Cache Storage that incorporates general partial, fragment, and other Rails caching jobs into a cohesive unit that anyone can use.

This new Redis Cache Store supports Redis::Distributed, for Memcached-like sharding across Redises. It’s fault tolerant, so will treat failures like misses, rather than kill the request with an exception. It even supports distributed MGETs for that full partial collection caching goodness.

Rails 5.2.0 has Added support for PostgreSQL operator classes to add_index.The operator classes identify database operators to be used by the index for the columns. You can assign the same operator to all columns, or not. It currently only supports PostgreSQL.

Added ability to create PostgreSQL foreign keys without validation. Normally, PostgreSQL verifies that all rows in a table satisfy its foreign keys constraints. With this option, you can create these constraints without the overhead of checking if they are valid.

Rails 5.2.0 also has embraced the cherry of HTTP/2 with early hints. This means we can automatically instruct the web server to send required style sheet and JavaScript assets early. This means a faster page delivery.

On the topic of performance, Rails now ships with Bootsnap in the default Gemfile. This generally reduces application boot times by over 50%.

CSRF and XSS have enhanced that further in Rails 5.2 with the addition of a new DSL that allows you to configure a Content Security Policy for your application. We can configure a global default policy and then override it on a per-resource basis and even use lambdas to inject per-request values into the header such as account subdomains in a multi-tenant application.

In Rails 5.2, we’ve rectified the mess by deprecating the two different kinds of secrets and introduced a new shared concept called Credentials. Credentials, like AWS access keys and other forms of logins and passwords, were the dominant use case for secrets. Credentials are always encrypted. This means they’re safe to check into revision control, as long as you keep the key out of it. This means atomic deploys and there is no need to mess with environment variables.

Since Rails 5.1, we’ve also made great strides with Webpacker. So Rails 5.2 is meant to pair beautifully with the new Webpacker 3.0 release. Rails have fully embraced modern JavaScript with a pre-configured build pipeline run by Webpack. We keep strengthening that relationship.

Thanks again to everyone who continue to pour their love and support into Ruby on Rails! Happy Coding.

]]>

How to test pdf files

dileep — Mon, 29 Apr 2019 11:28:12 +0000

class EmployeeWriter attr_accessor :employee, :output_file def initialize(employee, output_file) @employee = employee @output_file = output_file end def export_to_pdf Prawn::Document.generate(output_file) do bounding_box([0, cursor], width: 200) do text “Name: #{employee.name}” text “Employee id: #{employee.employee_id}” text “Occupation: #{employee.occupation}” stroke_bounds end end And we have Employee class

  class Employee
    attr_accessor :name, :employee_id, :occupation
    def initialize(name, employee_id, occupation)
      @name = name
      @employee_id = employee_id
      @occupation = occupation
    end
  end

Now

EmployeeWriter.new(
    Employee.new("name", "employee_id", "occupation")
    'filename.pdf'
  ).export_to_pdf

will give us the following pdf Now let us write test which ensure pdf has right contents. We read the data using Pdfreader First get the pdf-reader

gem install pdf-reader -v 1.4.0

RSpec.describe EmployeeWriter do
  it "should have correct content" do
    employee = Employee.new("employee_name", "employee_id", "developer")
    EmployeeWriter.new(employee, 'employee.pdf').export_to_pdf
    reader = PDF::Reader.new('employee.pdf')
    pdf_content = reader.pages[0].to_s
    expect(pdf_content).to include('Name: employee_name')
    expect(pdf_content).to include('Employee id: employee_id')
    expect(pdf_content).to include('Occupation: developer')
  end
end

]]>

Red Panthers community report card, 2017

coderhs — Mon, 29 Apr 2019 11:28:12 +0000

Building a Multitenant application with Apartment gem

nimmy — Mon, 29 Apr 2019 11:28:12 +0000

Single tenancy Every customer is having their own software instance and DB and it serves for only one customer. Here, the software can be customized to meet the specific customer requirements as it is independent.

Multi-tenancy

Multitenancy implements a shared architecture where a single instance of the software application serves multiple customers. We call each customer as a tenant. Multitenancy ensures data isolation for each client. A multitenant app is easier to maintain and is economical. The core principle in multitenancy architecture approach is often misunderstood with multi-instance architectures. In multitenancy architecture, it is the single instance of the application which is being shared between multiple tenants. Hence, multi-instance architectures aren’t the same as multi-tenant architectures.

Advantages

Shared infrastructure lead to lower costs by sharing same power resources and software across its clients.
In single-tenant applications, you have to manage different sets for each client while in multitenant applications you have to monitor and provide administration for a single platform only.
Entire system becomes more scalable
Upgrading the software version and installation becomes easier for multitenant applications.
Easier to add new clients.
Configuration can be changed without touching codebase.
Easy maintenance

Multi-tenancy on the database layer or model layer

Multitenancy can be done on the database layer or model layer. Both solutions have pros and cons. The concept of multitenancy on database layer is creating for each user a new database or schema which is the best method to avoid data leaking to another tenant. But some applications have architecture constraints where only one database can exist in the application. The concept of multi-tenancy on the model layer is faster and easier to implement based on ActiveRecord default scopes, but also riskier. In one database, each customer is connected with his own tenanted models by the foreign key. A bug in the application can cause irreversible data leaks from one tenant to another. The two most popular Ruby Gems which allow for creating multi-tenancy in Rails are:

apartment tenancy on database layer: https://github.com/influitive/apartment.
actsastenant tenancy on model layer: https://github.com/ErwinM/actsastenant.

It’s impossible to conclude a universally best solution for multi-tenancy, but Apartment gem seems most reasonable to use when we use Postgres schemas. In this blog post, we are gonna use Apartment gem to implement multitenancy in Rails application.

Using Apartment gem

Apartment gem provides tools to handle multiple tenants in our Rails application. It has a simple installation process and it basically creates tenants and to each tenant, the gem will automatically assign a new isolated schema and the creation of isolated database instances is also possible with Apartment.

Let’s create a new Rails app

rails new blog-post -d postgresql

cd blog-post

bundle exec rake db:create

Adding the Apartment gem to your Gemfile

Now open up the Gemfile in your rails app and add,

gem 'apartment'

Now generate the apartment config file,

bundle exec rails g apartment:install

This will create a config/initializers/apartment.rb file as the configuration file for us. There is a bunch of configuration stuff to use.

Create the model

For example usage, we will be creating models author and post.

bundle exec rails g model user name

bundle exec rails g model article content

Here users play the role of tenants and articles will be tenanted data. Each user must have a separate schema in Postgres database. We assume that user’s name is a valid Postgres schema name. We have to add a unique constraint to it. In the users table migration file,

class CreateUsers < ActiveRecord::Migration[5.1]
  def change
    create_table :users do |t|
      t.string :name, null: false
    end
    add_index :users, :name, unique: true
  end
end

Also, add validation in app/models/user.rb:

validates :name, presence: true, uniqueness: true

Then run migration:

bundle exec rails db:migrate

In Apartment gem, each tenant should be created and deleted when the new author is created and removed. Adding Apartment methods calls in app/models/user.rb :

class User < ApplicationRecord
  validates :name, presence: true, uniqueness: true
  after_create do |user|
    Apartment::Tenant.create(user.name)
  end
  after_destroy do |user|
    Apartment::Tenant.drop(user.name)
  end
end

This will automatically create a tenant whenever a user is created by taking the value of name field in the User model (create a Postgres schema for new the user) and remove from the database it when the user is deleted.

Specify common models

In any multitenant application, some models will be common for all the tenants and some will be tenant-specific models. In our example, Article model will belong to a tenant and the User model will be excluded from it and remain in the global (public) namespace. So we need to specify it in config/initializers/apartment.rb:

--------------------------
Apartment.configure do |config|
# Add any models that you do not want to be multi-tenanted, but remain in the global (public) namespace.
# A typical example would be a Customer or Tenant model that stores each Tenant's information.
config.excluded_models = %w{ User }
--------------------------

Now, we have the User model as the common model.

Specify tenant names

Apartment gem needs to specify tenant names and assign them accordingly to run migrations for them and create proper tables in Postgresql schemas. In our case, we have to modify only one uncommented option below the excluded models line that we have added in the previous section in config/initializers/apartment.rb to:

config.tenant_names = lambda { User.pluck(:name) }

Specify a middleware

To tell the application to work with subdomains, ensure that the following line at the end of the apartment.rb file is left uncommented.

Rails.application.config.middleware.use Apartment::Elevators::Subdomain

See it works

Finally, see how multi-tenancy in the Apartment gem works by creating two users in Rails console.

User.create (name: 'Angel')
User.create (name: 'Sam')

This will create users and also two schemas with articles table for both of them. By default, we are in the public schema. In order to switch to a different schema we use a special Apartment method:

Apartment::Tenant.switch!('Angel')

This will set current apartment to user named Angel. Creating some posts for this user in this tenant:

Article.create(content: "Angel’s article")
Article.all
=> #]>

Now switch to the second user and show all articles:

Apartment::Tenant.switch!('Sam')
Article.all
=> #

We get an empty result, see multitenancy working:) By the way, showing all users:

User.all
=> #, #]>

As the User model is excluded from multi-tenancy it can be seen globally. The public schema has its own articles table, so user’s posts will not be visible in this schema. More information can be found on Github gem page, like the built-in ability of Apartment gem to switch tenants per HTTP request.

References

https://github.com/influitive/apartment

]]>

What is Test Driven Development?

levi — Mon, 29 Apr 2019 11:28:11 +0000

Test Driven Development (TDD) is a software development process that weighs on a short development cycle. The developer first writes an automated test defining the new feature or update, which fails at first, then write minimal code for the tests to pass, then refactor the code according to the needed standards. TDD is helpful in keeping the code neater, simple and bug-free TDD starts with designing and developing tests for every small functionality of an application. The test is developed which will specify and validate what the code will do. n the normal Testing process, we first generate the code and then test. Tests might fail since tests are developed even before the development. In order to pass the test, the development team has to develop and refactors the code, which means changing the code without affecting its actual behaviour. We usually follow the following sequences in TDD.

Add a test
Run all tests and see if the new one fails
Write some code
Run tests
Refactor code
Repeat

The simple concept of TDD is to write and correct the failed tests before writing new code. This helps to avoid duplication of code as we write a small amount of code at a time in order to pass tests. Test-Driven development is a process of developing and running automated test before actual development of the application. Hence, TDD sometimes also called as Test First Development. In short, TDD is

Write a test
Make it run.
Change the code to make it right i.e. Refactor.
Repeat process.

Why use Test Driven Development

Early bug notification.Developers test their code but in the database world, this often consists of manual tests or one-off scripts. Using TDD you build up, over time, a suite of automated tests that you and any other developer can rerun at will.
Better Designed, cleaner and more extensible code.
- It helps to understand how the code will be used and how it interacts with other modules.
- It results in better design decision and more maintainable code.
- TDD allows writing smaller code having single responsibility rather than monolithic procedures with multiple responsibilities. This makes the code simpler to understand.
- TDD also forces to write only production code to pass tests based on user requirements.
Confidence to Refactor
- If you refactor code, there can be possibilities of breaks in the code. So having a set of automated tests you can fix those breaks before release. Proper warning will be given if breaks found when automated tests are used.
- Using TDD, should results in faster, more extensible code with fewer bugs that can be updated with minimal risks.
Good for teamworkIn the absence of any team member, other team members can easily pick up and work on the code. It also aids knowledge sharing, thereby making the team more effective overall.
Good for DevelopersThough developers have to spend more time in writing TDD test cases, it takes a lot less time for debugging and developing new features. You will write cleaner, less complicated code.

Test Driven Development is a very effective method to follow to keep our code, neat and bug-free. ]]>

Git – Resolving Conflicts

levi — Mon, 29 Apr 2019 11:28:11 +0000

git needs your help in deciding which change needs to be incorporated in the final merge of the branch. Git can often resolve the difference between branches and merges the branches automatically. Usually, the changes are on different lines or even different files. This makes it easy for the computer to understand. However, there are few changes that git cannot resolve without the user’s help. This happens usually when different people make changes to the same line in a file or a person edits the file while another deletes it. This causes a conflict of changes while merging the branch. We need to resolve all the conflicts before we merge a pull request to the git server. If we have a merge conflict between the compare branch and the base branch, we can see the files and the changes that caused the conflict above the merge pull request button. The merge pull request button is deactivated until the conflict is resolved. To resolve the merge conflict, we need to manually edit the conflict inflicted changes. We must edit and specify the final changes that are to be merged. We can either resolve the changes in the local computer and then push to the repository or we can directly edit the changes in the conflict editor of the git server like github or gitlab. If we have any conflicts in the command line, we cannot push the local changes to the server until we resolve the merge conflicts. If we try to merge the branches with a conflict from the command line, we will be getting an error message. A sample error message is given below.

git merge BRANCH-NAME
Auto-merging example.md
CONFLICT (content): Merge conflict in example.md
Automatic merge failed; fix conflicts and then commit the result

Once the conflicts are resolved and the changes are pushed, be happy. You can now merge the branch with no worries.]]>

Setting up your own private GIT server

levi — Mon, 29 Apr 2019 11:28:11 +0000

git user and a .ssh directory for the user. Follow the commands given below.

$ sudo adduser git
$ su git
$ cd
$ mkdir .ssh && chmod 700 .ssh
$ touch .ssh/authorized_keys && chmod 600 .ssh/authorized_keys

Let’s add some SSH keys to the authorized_keys file for the git user. They should be like

$ cat /tmp/id_rsa.john.pub
ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQCB007n/ww+ouN4gSLKssMxXnBOvf9LGt4L
ojG6rs6hPB09j9R/T17/x4lhJA0F3FR1rP6kYBRsWj2aThGw6HXLm9/5zytK6Ztg3RPKK+4k
Yjh6541NYsnEAZuXz0jTTyAUfrtU3Z5E003C4oxOj6H0rfIF1kKI9MAQLMdpGW1GYEIgS9Ez
Sdfd8AcCIicTDWbqLAcU4UpkaX8KyGlLwsNuuGztobF8m72ALC/nLF6JLtPofwFBlgc+myiv
O7TCUSBdLQlgMVOFq1I2uPWQOkOWQAHukEOmfjy2jctxSDBQ220ymjaNsHT4kgtZg2AYYgPq
dAv8JggJICUvax2T9va5 gsg-keypair

We now append them to the git user’s authorized_keysfile in its .ssh directory.

$ cat /tmp/id_rsa.john.pub >> ~/.ssh/authorized_keys
$ cat /tmp/id_rsa.josie.pub >> ~/.ssh/authorized_keys
$ cat /tmp/id_rsa.jessica.pub >> ~/.ssh/authorized_keys

We can now set up an empty repository by running git init with the –bare option, which initializes a repository without a working directory.

$ cd /srv/git
$ mkdir project.git
$ cd project.git
$ git init --bare
Initialized empty Git repository in /srv/git/project.git/

Now one can push their first version of their project into that repository by adding it as a remote and pushing up a branch. We can now use a hostname of the server in which we have set up git user and repository.

$ cd myproject
$ git init
$ git add .
$ git commit -m 'initial commit'
$ git remote add origin git@gitserver:/srv/git/project.git
$ git push origin master

Now, others can clone the directory and push back the changes.

$ git clone git@gitserver:/srv/git/project.git
$ cd project
$ vim README
$ git commit -am 'fix for the README file'
$ git push origin master

We can restrict a user to have only git related activitis using a shell tool called git-shell. If we set the shell to a user’s login shell, he cannot have normal usage. To use, specify the git-shell instead of bash or csh for your user’s login shell.First add git-shell to /etc/shells if it does not exist.

$ cat /etc/shells   # see if `git-shell` is already in there.  If not...
$ which git-shell   # make sure git-shell is installed on your system.
$ sudo vim /etc/shells  # and add the path to git-shell from last command

Now you can edit the shell for a user using chsh -s :

$ sudo chsh git -s $(which git-shell)

Now, the git user can only use the SSH connection to push and pull Git repositories and can’t shell onto the machine. If you try, you’ll see a login rejection like this.

$ ssh git@gitserver
fatal: Interactive git shell is not enabled.
hint: ~/git-shell-commands should exist and have read and execute access.
Connection to gitserver closed.

If you are in need of higher control over your git repositories, setup your own private git server.]]>

Gitk

levi — Mon, 29 Apr 2019 11:28:11 +0000

gitk is a command that is used for visualizing the commit graph and displaying all the history of the commits made and the information of files in the trees of each revision made. gitk is a very powerful GUI tool which is very handy to the command line ignorant. To get started with gitk, we need to install it first. For Ubuntu users, follow the commands given below.

sudo apt-get update
sudo apt-get install gitk

To get installed in Mac, follow these commands.

/usr/local/bin/git
brew doctor
brew update
brew install git
which git

To bring up the gitk interface, run the command.

gitk

Here is a sample gitk interface. The entire history of commits is shown in the GUI interface. The current head, the local branches, the commit message and who committed the messages are displayed. We can see the date and who committed the changes. Also, the files changed can be viewed. gitk is very helpful for beginners who are not used to command line interface.]]>