DEV Community: Naveen Honest Raj

Case study on Ruby Gem Contribution: activeadmin-mongoid

Naveen Honest Raj — Sat, 26 Jun 2021 08:30:42 +0000

This article is originally posted here. Checkout the article and related articles here.

For the people who are very much in the Rails development, you definitely should've used Activeadmin on one of your projects. If not, please have a look at it. It is an amazing gem ran by a very understanding community.

For those who aren't familiar with Rails, this gem provides us to build admin controlled management side for the models present in the application quickly. Provides set of conventions and working along those lines, you can quickly get your admin dashboard ready. For Django-familiar people, it is similar to django-admin.

The gem activeadmin sits very well with the relational DB using Rails activerecord and for the projects that uses NoSQL DB like Mongo, there is another gem under the same umbrella - activeadmin-mongoid (https://github.com/activeadmin/activeadmin-mongoid)

Little story behind activeadmin-mongoid

ActiveAdmin is holding off on pulling Mongoid support into the core ActiveAdmin application. Maybe in future activeadmin will provide support for NoSQL directly through its gem.

This gem's repo was pulled into the ActiveAdmin org from previous work done by Elia Schito. Currently, it is maintained by Grzegorz Jakubiak, Nic Boie, JD Guzman, Elia Schito and other ActiveAdmin and community members.

Quick technical glimpse about the activeadmin-mongoid

Mongoid based Rails projects mostly won't require activerecord in their model methods and also wouldn't need any migration because we aren't dealing with the usual ideas of the SQL world.

Similarly, activeadmin-mongoid as a gem also avoids to require Rails's activerecord related elements. This is something to be considered when introducing any new additions to the gem. (atleast at the time of writing)

What was the issue

activeadmin-mongoid depends on the activeadmin and holds the generator calls like rake activeadmin:install to generate the initializer files. By default, the activeadmin generates configuration files and a db migration file as well.

So like we mentioned, db migration is valid in the world of SQL (within our context of explanation), but considering with Mongoid, that file is completely unnecessary and users were deleting them after it gets generated because it makes no sense and no use.

One user pointed that out and raised an issue on that. https://github.com/activeadmin/activeadmin-mongoid/issues/137

So I was a little bit curious to try solving that out. There were little discussions went on the thread and Nic Boie, one of the maintainers gave it a shot and added what he tried and what was the result. That helped me to set the first direction towards solving the issue. Thanks to Nic!

Towards solution

Ideally, Nic Boie's solution solved the problem. It stopped the command from generating the migration file. But, while trying to open the class and override the method to make it do nothing, he has to require certain files and these files required has dependent requires and one of them brought in the activerecord related files. So, now my task is to do the exact thing what Nic did, but without letting the activerecord getting required through any dependent calls or so.

This is the solution Nic provided

require 'active_admin/mongoid'
require 'generators/active_admin/install/install_generator.rb'

ActiveAdmin::Generators::InstallGenerator.class_eval do

  # Make this a no-op so the AR migrations are not installed when ActiveAdmin-Mongoid is used.
  def create_migrations;end
end

Reading through the activeadmin gem

So, I took my time to read through the activeadmin gem and see for the class that Nic used above to override with class_eval.

Studying the class ActiveAdmin::Generators::InstallGenerator from here helped me to understand that the current class is the one which requires activerecord related files, but the parent class of this class doesn't requires any of those.

So the solution I came up with was, to go change the parent class of ActiveAdmin::Generators::InstallGenerator to do the following:

When a class subclasses from it, I need to change the way the subclass is described.
Then either override the method definition or disallow it from overriding.

self.inherited method

Ruby has a wonderful hook on class called inherited which will be called when a class is used by another class to derive itself. Using that inherited you can control specific way of the derived class. Cool, isn't it? I even tweeted about it here https://twitter.com/nav_devl/status/1405329547701096452

The only caveat with the idea I had was, I assumed when the self.inherited was called, the subclass will be fully defined and I can just remove/override the definition of create_migrations method. But turns out, when the self.inherited was called, there are no user defined methods present. Only after the self.inherited is finished the the class implements all other user definied methods. 😔

self.method_added

Again, Ruby as charming as always, provides us with a hook called method_added and this is called every time a new method method definition is added to a class. Now can you see where we are heading towards?

So we are going to combine the advantage of self.inherited and self.method_added 🤯

Moving with solving

So, now our next set of action is very simple.

Define an empty create_migrations in the parent class.
When a class is derived from it, we are redefining the self.method_added's definition. Classy, right? 😎
So, if the derived class's name is ActiveAdmin::Generators::InstallGenerator we are redefining the self.method_added of that subclass to remove the method definition of create_migration
remove_method will remove only the method definition scoped to that class, so our derived class will now lookup to parent class for definition when create_migration is called.
And we have an empty NO ACTION definition in our parent class.
No activerecord related items are required while doing this.
Bam! 🎉🎉

Code

Rails::Generators::NamedBase.class_eval do
  def create_migrations
  end
  def self.inherited(klass)
    super
    if klass.name == "ActiveAdmin::Generators::InstallGenerator"
      klass.class_eval do 
        def self.method_added(method_name)
          super
          remove_method method_name if method_name == :create_migrations
        end
      end
    end
  end
end

This is my implementation and the PR is here (https://github.com/activeadmin/activeadmin-mongoid/pull/164) It is yet to be merged. 2/3 reviewer approved and hopefully I think it gets approved and merged.

Help with getting started in building bot for Slack

Naveen Honest Raj — Wed, 16 Sep 2020 17:47:38 +0000

I am trying to build a bot for Slack. I somehow managed to do the MVP version of it using Python's slack event API library slackeventsapi

Today in an evening discussion, my friend suggested that I should probably try my hands with Hubot or Bolt framework in JS for building slackbot because those frameworks makes use of RTM(Real time messaging). The discussion couldn't go further because of some time constraint. Now I have been googling around to try and understand what kind of pros I'll get over choosing one over other and why?

If someone could help me by explaining it in a bit easier terms, it would be so helpful. Thanks a lot :))

Running own private email server and the problems?

Naveen Honest Raj — Fri, 10 Jul 2020 12:58:00 +0000

I created my own email server using postfix and implemented a catch-all email approach. I am a beginner in creating and running my own email server but read few articles and successfully ran it.

The approach I followed is written in here https://naveenhonestraj.in/creating-an-incoming-email-server-and-sending-data/

My end goal is to catch all the email sent to a specific domain, say (@example.com) and make a POST call(something like a webhook action) with payloads that contains all the information of the email sent.

I successfully made this and now can make those POST call with proper payload, but I am not aware of the problems/cons along running own server with the catch-all approach.

If somebody who worked on the similar lines can share their thoughts and opinions on this, it would be very very helpful. Thanks.

Timeout with a third party library or another server - How to handle?

Naveen Honest Raj — Tue, 23 Jun 2020 12:35:06 +0000

This example I am stating obviously a rare scenario, but I would like to understand how this would be handled? (or they should be totally avoided?)

Consider there's two application server (AS1 and AS2) having their own databases(DB1 and DB2). An HTTP call to one AS1 will internally make HTTP call to AS2. Once AS2 validated the payload from AS1, it will write to DB2 and returns an hash, which AS1 will store in DB1.

Looks very simple to construct, but how can we handle this following scenario. Say, AS1's internal HTTP call to AS2 has a specific timeout (let's assume 15seconds). In that time period, AS2 writes to DB2 but didn't return before the timeout, so AS1 don't have the hash and now it cannot make a duplicate call to do AS2 again.

How should this be handled? I know the scenario looks vague for few of you. But let's pop up some discussion further if needed. Thanks.

Writing your first Business Model in Hyperledger Composer

Naveen Honest Raj — Wed, 21 Feb 2018 04:53:44 +0000

This article focuses on creating a simple business model that helps you with visualizing the abstract nature of Hyperledger Composer’s language.

If you are confused on where to start or wasted a lot of your time in getting started with Hyperledger Composer, you should read this article. My co-worker, Varun has explained it in such a simple way that anyone can understand it.

What is Business Network Definition?

The Business Network Definition is the core definition that holds the Hyperledger Composer’s programming model. In short, it controls the model definition, the relationship between them, the access control over them and the actions that could be performed on/with them.

BND has three core components :

The Model written in .cto files
The Business Logic written in .js files
The Access Control Logic written in .acl files

(Optional) There is a Query file written in .qry files that help us to query over the persistent DB.

These three components are easy to maintain and they govern our whole business application on the Composer.

Let’s see how to write a manageable simple model file that helps anyone understand most of our business logic. We will implement this in the business logic file.

Understanding The Key Concepts Of A Model

Before writing our own model, let us understand the key concepts of it. In a model file, you will be defining the following,

A namespace namespace org.skcript.svr
Resources, which includes
1. Participants
2. Assets
3. Transactions
4. Events
Optional import statements that are used to inherit or import other model files.

Resources Are Everything In A CTO File

A ‘Participant’ denotes the person who does the action (in simple terms). This is to whom the ID is issued and this is the one who performs transactions.

For example: Consider the example

participant Author identified by id {
    o Integer id
    o String name
    o String email
    o String specialized_in 
    o Double age
}

In the above example, we see there’s a participant named Author and the keyword identified by is used to select the primary key. Here, it is id field that acts as a primary key. We will know the wide applications of having this identified by on right field to have an easy and readable access to the model.

The circles are nothing but lower case ‘o’ (The O, yeah ! ). Composer’s model file has a unique way of representing a new key in their object. But you will get used to it.

Assets are the resource which our business model has. Considering our above example, Author is a participant, then Post will be the asset that he holds. And we know that every post will always belong to an author. There can never be an asset that won’t belong to an author. This can be done by creating a relationship between our participant and asset. This is easy-peasy because of the CTO’s modeling language.

P.S. You should be careful with relationship because it is unidirectional and you can’t do the vice versa which you can do in most of the application frameworks.

Example:

/**
* An enumerated type
*/
enum Category {
  o AI
  o BLOCKCHAIN
  o WEB-DEVELOPMENT
  o BACKEND
  o DESIGN
  o FUN
}

/**
 * A post asset.
 */
asset Post identified by id {
  o String id
  o String title
  o Category category
  o DateTime timestamp
  --> Author author
  --> Author coAuthor optional
}

In the above example, as we learned earlier identified by is used with id as primary key which makes sense. Right? Now you can understand.

But where’s the new thing coming up? No rush. Let’s take it slow.
Let’s see the Line 21 - we see an arrow. Okay. I didn’t write it because it looks good on the code and it’s not a comment too. That’s again our Composer’s modeling language’s weird way of writing relationship. So we should read it as Post belongs to Author. That’s simple. Done.
In Line 22 , we can see there’s a new keyword optional. This helps us avoid mandatory entry to create an asset. This is defined as optional by thinking that there may or may not be a coauthor for a particular post.

Next, why enum ? It’s for managing a neat code. As our articles goal is not only to learn how to write a model but also to write a good one that can be easy to read and update.
So enum holds the possible values our field can take. So we defined an enum called Category and we gave it all the possible values it can take. Now in Line 19 we used it and created a category of enum Category .

Transactions are the process in which our participants do the operation on assets. Considering our scenario, author creating a post is also a transaction.
Example:

transaction createPost {
  --> Author owner
  o String title
  o Category category
}

The above transaction definition emphasizes that we are creating a post by pointing out the author of the post. We also provide title and category while creating the post.

P.S: In our next post, we will learn more about the transactions and transaction processor functions.

Events are used to trigger some other third party application. You can write the logic for the event which will help you to send an email about the author’s new post. These events can be used to help you to send emails if and only if you subscribed to the particular author which helps to avoid spam and improves integrity. Events are also defined the same as transactions. The purpose is only different. Used with event keyword for declaration.

The Endless Possibilities Of The CTO File

You can still segregate the model declaration by abstract keyword which won’t create participant or asset in the registry, rather is used to inherit from the other resources.

Example: Considering the same scenario, try to understand the following code

abstract Participant UserInformation identified by name {
  o String name
  o String address
  o String email
  o Integer age
}

participant Author identified by id {
    o Integer id
    o String specialized_in 
    o UserInformation user_information
}

We created an abstract participant which holds most information about a user and we inherit and use that in our Author participant. This helps us have a clean model that still maintains Single Responsibility Principle. We can do abstract type for assets and transactions too.

Conclusion

There are much more magical things like extends that we can do with CTO file. But let’s end it clean and easy here. After you write your first model, you will figure out most of the conventions you might need to follow to have a maintainable code. Wish you a good luck, readers.