DEV Community: Merdan Durdyyev

Concerns in Rails — A Guide and an Example

Merdan Durdyyev — Mon, 20 Mar 2023 14:50:05 +0000

Welcome

Hello dear friends, coders and enthusiasts.

Today we are going to dive into the topic of “Concerns” in Ruby on Rails. Concerns are an important topic in Ruby on Rails but anyway, it’s up to a developer to decide whether to use them or not. And besides that, they need to be used carefully to avoid issues of so called “circular dependency” and revealing too much info of the model to the Concern.

So, let’s get started…

What does a Concern help with?

A Concern is just a ruby module that extends ActiveSupport::Concern module.

You might have already seen the folders that are created by default when creating a new Rails project. Those folders are ‘app/controllers/concerns’ and ‘app/models/concerns’. These folders are where concerns should be placed.

Using a concern lets you extract the common logic from different classes into a reusable module.

What we have to do to extract some logic into a concern is write a concern module that extends “ActiveSupport::Concern” module. So, let’s write an Archiveable concern module.

module Archivable
  extend ActiveSupport::Concern

  included do
    scope :visible, -> { where(archived: false) }
    scope :archived, -> { where(archived: true) }
  end

  def archive
    update_attribute :archived, true
  end
end

So, to use it in our models, we just need to include the above described module within our model classes.

class Post < ApplicationRecord
  include Archivable

  has_many :comments

  # ...
end

class Comment < ApplicationRecord
  include Archivable

  belongs_to :post

  # ...
end

As you already might have notice, this code assumes that you have ‘archived’ attribute in both of the models (‘Post’ and ‘Comment’) to operate on. Otherwise we won’t be able to use execute the intended code, because the ‘Archivable’ module makes use of ‘archived’ attribute.

Two important parts of a Concern

A concern can provide two blocks that comprise different types of methods to be used in the included class.

included

The code inside this block is evaluated in the context of the including class. For instance, if a class ‘Comment‘ includes a concern, anything inside the ‘included’ block will be evaluated as if it was written inside the “Comment” class.

You can add validations, associations, scopes, or other methods, and all of these become instance methods of the including class.

class_methods

All the methods added inside this block become class methods of the including class. As a second option, you can create a nested module called “ClassMethods” where you can put your class methods.

module Visible
  extend ActiveSupport::Concern

  # This is where you place instance methods
  included do
    def toggle_visibility
      toggle!(:is_visible)
    end
  end

  # This is where you place class methods
  class_methods do
    def get_all_visible
      all.select { |item| item.is_visible? }
    end
  end
end

Here’s the “Visible” concern where the two above-mentioned blocks reside and we place our instance and class methods accordingly within those blocks.

Good approaches to using Concerns

Single Responsibility Principle

A good concern should be able to work in isolation, so it must be dependency-free. It should have a very concrete and limited responsibility.

Bear in mind the Single Responsibility Principle when extracting something to a concern. That being said, you need to extract just a small, reasonable code to a concern so that it stays manageable and include’able into several locations in the future.

Construct a concern that, for instance, just manages Archive’ability, Exportability, Notifiability of a model, and not many of those features.

Using Concerns for multiple models

It is a good approach to extract Concerns when they tend to be useful in several models. This way we are obeying the DRY principle and using the same piece of code in several models. It shrinks the code and makes it manageable.

A good example of this might be “Exportable” module/concern. This concern can be included in several models, like: Email, Document, Table, Drawing and etc… This way, it becomes a very useful accessory to use.

Conclusion

We have covered the basics of implementing concerns in Ruby on Rails and it gives you a basic idea of why’s and how to’s about using concerns.

Actually no code is perfect and it’s up to you to decide how to organize things and make the code perfectly readable. You need to use your own judgment and weigh the pros and cons of either of the options.

Hope to meet you in the next article !

Stay safe, stay healthy, stay hungry !!! 👋

Rails Service Objects — A Guide and an Example

Merdan Durdyyev — Wed, 08 Feb 2023 11:34:38 +0000

Introduction

Hello dear coders, enthusiasts and learners!

Hope you are all doing fine and ready to learn some more tips about Ruby on Rails. This time we are going to mention one of the ways to refactor the code in Ruby on Rails projects.

Actually, code logic that is unrelated models, or controllers can be extracted to separate parts like, Modules, Concerns, Service objects, Helpers and etc. And this time we are going to focus on Service objects.

Do we actually need Rails Service Objects ?

Ruby on Rails is an excellent framework for building MVP or developing large scale applications. As years pass by, the codebase grows into a monstrous giant and you start to understand it’s time to take a different approach.

You must keep unconcerned things separated, everything in its own place, follow DRY concept, skinny models, fat controllers, and etc. to keep things manageable, properly organized and sane.

That’s the next step when you start extracting part of the code into Service Objects, Concerns, extra Modules, or even start migrating to microservices, to prevent the codebase from bloating and exploding one day.

So, the answer is “YES”. We do actually need Service Objects, to offload much of the workload from controllers and other parts of the code.

What are Services Objects in Rails?

When you business logic can’t fit either into models, or controllers, that’s the time you need to go on with Services, to be able to separate unrelated business logic into its own Ruby object.

> Services objects are just Plain Old Ruby Objects (PORO) that are intended to perform a single action at its core.

There’s an opinionated discussion whether where to place your service objects. So, generally, service objects are placed inside either in “lib/services”, or “app/services” folders. You can read couple of articles or discussions on that and come to a decision of your own.

So, a Service Object is a way of encapsulating a part of logic, a single action, or function, into an independent single-use object. It serves a single purpose and exposes only one public method, and is built around that method.

That single public method is generally called “call”, Gitlab calls it “execute” in its services, some like calling it “perform”. But that’s up to you how to call it, as long it is a single public method that will be executed when calling the service.

Creating a Service Object

To create a Service object, we can create a directory for it and create a new file with following command:

$ mkdir app/services && touch app/services/tweet_creator.rb

So, let’s create a new TweetCreator in a new folder called app/services:

# app/services/tweet_creator.rb
class TweetCreator
  def initialize(message)
    @message = message
  end

  def send_tweet
    client = Twitter::REST::Client.new do |config|
      config.consumer_key        = ENV['TWITTER_CONSUMER_KEY']
      config.consumer_secret     = ENV['TWITTER_CONSUMER_SECRET']
      config.access_token        = ENV['TWITTER_ACCESS_TOKEN']
      config.access_token_secret = ENV['TWITTER_ACCESS_SECRET']
    end
    client.update(@message)
  end
end

After you have created the “TweetCreator” Service object, you can call it anywhere in your code, with:

TweetCreator.new(params[:message]).send_tweet

What are examples of using a Service Object?

There can be dozens of situations when we need to extract some part of the code into Service objects. But, just to count some of them, these are the the situations and examples:

Send a tweet to Twitter — TweetCreator
Follow a user in Facebook — FacebookUserFollower
To charge a customer in Ecommerce — CustomerCharger, PaymentCharger
Send a post to Facebook — FacebookPoster
Try a payment transaction to payment services (Paypal, Stripe)

These are just some of the widely used scenarios of Service objects. But of course, your project can have something very different compared to these examples. So, analyze it, and if it does not fit into model or controller, move it out to a Service Object.

Rules for writing good Service Objects in Rails

There are many ways you can name your Service Objects. But you need to stick to a single naming convention you chose in you own codebase to be able to easily differentiate Service Objects.

Here are some options for choosing naming conventions:

UserCreator, PaymentCharger, WelcomeMessenger, AccountValidator
CreateUser, ChargePayment, MessageUser, ValidateAccount, etc…

Here are general rules for writing meaningful and reasonable Service objects:

Only one public method per Service object
Name Service objects like regular roles in a Company (TweetCreator, TweetReader, FacebookPoster, etc.)
No generic objects to perform several actions
Handle exceptions inside the Service object.

Benefits of using a Service Object in Rails

Service Objects are a great way to decouple your application logic from your controllers. You can use them to separate concerns and reuse them in different parts of your application. With this pattern, here are the benefits you get:

# Clean controllers
Fat controllers, bloating code within a class, are a sleeping dragon, napping monster, that can wake up one day and cause you tons of trouble. When that happens, you might get lost in the tens or hundreds of lines of code, not understanding what it actually does. So, it is an advantage to have a clean, tidy few lines of code that whispers you what it is intended for while you are reading it.

# Ease of testing
Applying separation of concerns, and extracting the unrelated pieces of code, so that they live on their own, allows easier testing of code and interacting with them independently.

# Reusable service objects
Extracting some code to specific Service Objects, gives you a freedom of calling them wherever you want, in your controllers, background jobs, or other services. Thus, you get a reusable piece of code.

# Separation of concerns
Rails controllers see Service objects and interact with them when required. This provides a way to decouple lots of logic into separate piece of code, especially if you want to migrate to microservices architecture. In that case you can extract and move those services with minimal distraction and modification.

Syntactic Sugar for Service objects

Just think about it, this feels great in theory, but TweetCreator.new(params[:message]).send_tweet is a lot to write. It is too verbose with lots of redundant words. We need to instantiate it and call a method to send the tweet.

We need to shorten it to a single call, so that single call does it all for us. So, there is Proc.call that calls it and executes itself immediately with the given parameters.

A proccan be call-ed to execute itself with the given parameters. Which means, that if TweetCreator were a proc, we could call it with TweetCreator.call(message) and the result would be equivalent to TweetCreator.new(params[:message]).call

We can apply the same for the Service object.

Example #1

First, because we probably want to reuse this behavior across all our service objects, let’s borrow from the Rails Way and create a class called ApplicationService:

# app/services/application_service.rb
class ApplicationService
  def self.call(*args, &block)
    new(*args, &block).call
  end
end

After that, we can inherit TweetCreator from “ApplicationService”:

# app/services/tweet_creator.rb
class TweetCreator < ApplicationService
  attr_reader :message

  def initialize(message)
    @message = message
  end

  def call
    client = Twitter::REST::Client.new do |config|
      config.consumer_key        = ENV['TWITTER_CONSUMER_KEY']
      config.consumer_secret     = ENV['TWITTER_CONSUMER_SECRET']
      config.access_token        = ENV['TWITTER_ACCESS_TOKEN']
      config.access_token_secret = ENV['TWITTER_ACCESS_SECRET']
    end
    client.update(@message)
  end
end

And here is the magic “call”. We can call it in the controller this way:

class TweetController < ApplicationController
  def create
    TweetCreator.call(params[:message])
  end
end

Example #2

Here is one more example of a Service object, that extracts process of updating a trip to a separate Service object.

If we want to reuse this behavior for other service objects, we can add a new class called BaseServiceor ApplicationServiceand inherit from it for our TripUpdateService:

# app/services/base_service.rb
class BaseService
  def self.call(*args, &block)
    new(*args, &block).call
  end
end

And here is the “TripUpdateService”:

# app/services/trip_update_service.rb
class TripUpdateService < BaseService
  def initialize(trip, params)
    @trip = trip
    @params = params
  end

  def call
    distance_and_duration = calculate_trip_distance_and_duration
                                                   (@params[:start_address],
                                                    @params[:destination_address])
    @trip.update(@params.merge(distance_and_duration))
  end

  private

  def calculate_trip_distance_and_duration(start_address, destination_address)
    distance = Google::Maps.distance(start_address, destination_address)
    duration = Google::Maps.duration(start_address, destination_address)
    { distance: distance, duration: duration }
  end
end

then we can update our controller action to call the service object correctly:

# app/controllers/trips_controller.rb
class TripsController < ApplicationController
  def update
    @trip = Trip.find(params[:id])
    if TripUpdateService.call(@trip, trip_params)
      redirect_to @trip
    else
      render :edit
    end
  end
end

Conclusion

Finally we are at the end of the article about Service objects.

As you might have already read, Service objects are really a helping hand to avoid code bloat and cluttering the code logic. But it is up to you whether to use it or not.

If the code fits the criteria when it should be extracted to a Service, then it’s a good opportunity for you to separate concerns and make your code much more readable.

Hope so much, this article helped you learn at least a tiny bit of something new about Ruby on Rails and some programming concepts.

See you in the next article. Stay safe and eager to learn !!!

Check whether a number is prime - Ruby

Merdan Durdyyev — Sat, 15 Oct 2022 10:24:26 +0000

WELCOME

Good time of the day, dear friends, coders and enthusiasts.
I haven't been posting for a long while, and have been primarily improving myself and working on some side projects. But the will to share what I have been learning and doing is still in me, burning wildly.
I have decided to start sharing some small articles about algorithms, and I decided to start from small.
Today we are going to look through an algorithm that checks whether the provided number is prime.

What is a prime number ?

Before getting into writing the code, let us understand what exactly the prime numbers are? Prime numbers are those numbers which can only be divisible by itself or 1. So, we will design a code which can fulfill the property of prime numbers.
That means, if the number is less than 2, we can immediately return 'false'.

Steps to reproduce

Return false if the provided number is less than 2 (because 0 and 1 are not considered to be prime numbers)
Run through all the numbers starting from 2 till 'n-1', where 'n' is a number provided as a parameter, and check whether 'n' is divisible by any of them
If we find that 'n' is divisible by any number in the range [2...n-1], then immediately break the loop and return 'false'
If we did not return a result in step 3, then return true. That means the number is prime

Code

If you want an immediate solution, you can use 'prime?' method provided by Ruby.

# Pre-defined class
require 'prime'

# Initializing the numbers
num1 = 17
num2 = 90
num3 = 29

# Printing if prime or not
puts num1.prime? # true
puts num2.prime? # false
puts num3.prime? # true

Ruby even provides a method for listing all prime numbers in a specified range

require 'prime'

Prime.each(27) do |prime|
  p prime
end

#=> 2, 3, 5, 7, 11, 13, 17, 19, 23

Ruby solution - 1

Here's the actual solution to check whether the number is prime, with Ruby. Of course, assuming that the input number is positive.

def is_prime(num)
  return false if (num < 2)

  (2..(num - 1)).each do |n|
    return false if num % n == 0
  end

  true
end

Ruby solution - 2

And if you want it shorter, as a one liner, here's the one that returns the result faster. Because it does not check all numbers in the range of [2...n-1], it only checks the numbers between [2...sqrt(n)].
It is considered that there are no divisors of a number higher than it's square root. So we are only checking numbers till square root of 'n'.

def is_prime?(num)
  return false if num < 2
  Math.sqrt(num)
    .to_i
    .downto(2)
    .each {|i| return false if num % i == 0}
  true

Solution provided above is one of the most optimal ones. Otherwise you can also check numbers between [2...n/2], that is till the half of the provided number. But of course, square root provides us with even less numbers to run through.

Javascript solution - one liner

Here you can see almost the same solution as provided in 'Ruby solution - 2', but in Javascript.

const isPrime = num => (num > 1) && Array(Math.floor(Math.sqrt(num)) - 1).fill(0).map((_, i) => i + 2).every(i => num % i !== 0);

This solution checks whether none of the numbers between [2...sqrt(n)] are divisible by 'n'. If it finds any divisor in that region, it returns false.

Conclusion

So, this is it, guys. Hope you gained some useful insights from this post or at least were happy to see beautiful one liner code snippets in Ruby and Javascript.
I will try to keep posting other useful solutions to common simple algorithms, so stay with Dev.to and all the developer community to keep improving.
Stay safe and Good luck!!!

Send SMS with Ruby Mechanize gem

Merdan Durdyyev — Mon, 07 Jun 2021 05:05:24 +0000

Welcome

Good day, dear friends, coders, and enthusiasts. Here's another post about how to do something else with precious Ruby. Today, we are going to write Ruby code to send SMS via a web app, provided by a Mobile service Carrier. No matter, be it US carriers like AT&T, Verizon, Sprint, or carriers in Russia like MTC, Megafon, and Beeline, we can use their web app (if they provide one) to automate sending SMS with Ruby.

Mechanize gem

Let's first make it clear, what a gem is.
Gem :

is a software package that contains packed Ruby application or library.
is used to extend or modify functionality in Ruby applications

To sum it up, we create Ruby gems, to be able to distribute them and make someone else's life easier. Other Rubyists can use them in their own code to import ready-to-use code, enhance productivity, and make development much faster.

Mechanize gem - is a ruby library that makes automated web interaction easy. Mechanize can follow links and submit forms. Form fields can be populated and submitted.

You can find more about the mechanize gem here:

Sending Test SMS

Here is the piece of code, where you can follow and get a clear explanation of how to fill in the form fields, submit it, and send the required SMS.
The following input fields and service URL are shown just as an example and maybe named differently in actual services.

'https://customer.verizon.com/' customer account URL
'login' input field
'password' input field
'Sms.DestinationAddress' input field
'Sms.Text' textarea field

require 'mechanize'

mech = Mechanize.new

# Ignore SSL certificate
mech.agent.http.verify_mode = OpenSSL::SSL::VERIFY_NONE 

# The login page
login_page = mech.get('https://customer.verizon.com/')  
# The login form
login_form = login_page.forms[0]       

# Filling in 'login' and 'password' input fields, and submitting.
login_form['login'] = '888-555-4444'
login_form['password'] = 'ABCDEFG'
login_form.submit

# The SMS form page
sms_page = mech.get('https://customer.verizon.com/SMS/Send')    
# The SMS form, the first and only form
sms_form = sms_page.forms[0]                                

# Entering sms number and sms message to send
# 'Sms.DestinationAddress' and 'Sms.Text' are input and textbox names
sms_form['Sms.DestinationAddress'] = '555-888-2222'
sms_form['Sms.Text'] = 'This is test message'
sms_form.submit

Automate SMS Sending

What we need to do now is just add the list of recipients (their numbers and corresponding messages). I have added just two of them. But you can add lots of more.
What I have done here is:

I added list of recipients;
I gave the list to an 'each' block.

You can make it even better by gathering all that code under a function that gets respective arguments and call that function for each of the recipients.

require 'mechanize'

sms_list = [
    { number: '555-666-8888', message: 'Get this SMS...'},
    # And lots of lots SMS numbers and messages...
    { number: '555-777-0022', message: 'Last one...'}
]
mech = Mechanize.new

# Ignore SSL certificate
mech.agent.http.verify_mode = OpenSSL::SSL::VERIFY_NONE 

# The login page
login_page = mech.get('https://customer.verizon.com/')  
# The login form
login_form = login_page.forms[0]       

# Filling in 'login' and 'password' input fields, and submitting.
login_form['login'] = '888-555-4444'
login_form['password'] = 'ABCDEFG'
login_form.submit

# The SMS form page
sms_page = mech.get('https://customer.verizon.com/SMS/Send')    
# The SMS form, the first and only form
sms_form = sms_page.forms[0]                                

# Send SMS to whole 'sms_list'
sms_list.each do |contact|
    # Entering sms number and sms message to send
    sms_form['Sms.DestinationAddress'] = contact[:number]
    sms_form['Sms.Text'] = contact[:message]
    # Submitting form, sending sms
    sms_form.submit                                             
end

Sum It Up

We have looked at just a small piece of what 'mechanize' gem can actually do. It has lots of more possibilities.
You can write a console application that surfs the given URLs and performs given operations without your attendance. So, the rest is up to you to discover. Go for it!

Ruby’s precious gems

Merdan Durdyyev — Tue, 06 Apr 2021 08:21:17 +0000

Welcome

Hello, dear friends, Ruby enthusiasts, and coders. I am glad you found time to spend your precious time to learn a bit more about precious Ruby and its precious “Gems”. So, let’s get to it.

What are Ruby gems?

A Ruby gem is a package that can be downloaded and installed as a part of your application you’re developing. They actually contain a packaged Ruby application or library. When you require an installed gem you’re adding extra functionality to your Ruby program.
Gems can be used to extend or modify the functionality of your Ruby applications. What is great about them is that they can be distributed and shared with other Ruby coders so that they can use them in their own applications.

Examples of gems

Gems make our life much easier, to the extent that we can save not hours, but weeks or months of coding time. By just adding the required gem to our application, we can quickly and easily integrate the feature it provides to our fresh baked application.
Here are some of the extra functionalities, ruby gems can provide for our applications:

Authentication (Devise, ruby-jwt, omniauth, etc)
Authorization (cancancan, pundit)
Testing (Rspec, shoulda-matchers, capybara, faker, etc.)
Search (elasticsearch)
Admin panels (activeadmin, administrate)
and hundreds and thousands of more and more…

Where can I find them?

You surely know about npm — node package manager and that it is a central point where you can search for and learn about javascript redistributable packages.
For Ruby gems, you can go to the RubyGems website. It is the Ruby community’s gem hosting service, where you can find, learn about, install them and publish your own gems.
There is yet another service where you can search for gems by category. It is “The ruby toolbox”, and it is a catalog of gems that keeps track of popularity and health metrics to help you choose a reliable library.

Managing Ruby Gems

Of course, to manage the gems you use in your application you need a package manager. Something should be keeping track of the gems you installed and their versions. That’s where the Bundler comes in. Well, Bundler is a tool for dependency management. It provides a consistent environment for your projects by tracking and installing the exact gems and versions that are needed.
Usually, you list the gems you use in a file called “Gemfile”. That’s the starting point where the Bundler analyzes and installs all the required gems to be used in the application.

Here are some of the commands you would use to manage your gems in a project:

gem list: Lists installed gems. Accepts an argument for filtering gems by name (example: gem list active)
gem install -v : Allows you to install a specific gem version (example: gem install sinatra -v 2.0.0)
bundle install: Installs all the gems listed in the Gemfile
bundle update: Installs all the gems, and if required, updates specific gems to the latest version available.

Conclusion

Before using a specific gem, please read its docs and analyze it thoroughly. The thing you should be considering is whether it exactly meets your requirements and whether it does not break your functionality when you decide to extend some of the features in your application.

I mean it must not be a burden when you decide to extend some functionality or add a new feature to your application. If you are suspicious that it can, then search for another one that fits best for it. For that, you have to carefully read the docs it provides on its website or its GitHub Readme file. It is better if you try using it in a small sample application, before integrating it into your desired application.

Here we come to the end of our article about Ruby gems, how to cook and how to eat them. I hope so much, it can be of use for anyone interested in Ruby, or maybe especially Ruby on Rails.

A short intro to React.js

Merdan Durdyyev — Fri, 15 Jan 2021 12:16:13 +0000

Welcome

Welcome, dear friends, dear readers, and guests.

As you all know, the software world is a general name for what coders do, and it has many subdivisions. The most important of them to count here are:

Backend (What is happening on the server-side)
Frontend (What is happening on the client-side)
Mobile (Dealing with mobile devices and mobile apps)

Among them, Frontend and Mobile products are used and seen visually by a client/user. A user/client does not see what is happening on the server part and it does not interest him. The part the user sees mainly appears on the browser. And this part is called the “Frontend” part of the programming world and it has a strong competition between the tools that are being used for it.

Anything we see on the browser, all the web pages, all the forms that we fill in, all the “like” and “star” buttons that we press are developed by one of the “Frontend” tools.

Now, let’s take a closer look at one of the widely used tools, called “React.js”.

What is React.js ?

“React.js”, is a library developed by a team at “Facebook”, used for “Frontend” development. Its first release was in May 2013. The library’s resource page is located at https://reactjs.org/. According to the 6-word sentence placed at the center of its web page, it states:

A JavaScript library for building user interfaces

For general statistics of its usage and popularity, you can take a look at its Github page, which is located at https://github.com/facebook/react.

The main advantage of React.js is that it allows a developer to decompose a large UI project into smaller reusable parts. These parts can later be used within another React.js based project or a web page. These reusable parts are called “Components“. You can separate each button, each text line, an icon, a logo, or a menu as another Component.

Another noticeable advantage of this library is that it allows composing both class-based and function-based (functional) components. As you may have already heard, functional programming is a trend nowadays. And this advantage of “React.js” also attracts those who are fans of functional programming.

Friends and opponents

In the world of Frontend, there are many other notable libraries and frameworks that go racing with “React.js”. Below is the list of the most used ones:

Angular
Vue.js
Backbone.js
Ember.js
jQuery
Svelte.js
Meteor.js
Polymer.js
Ext.js
and etc.

The most important thing we must underline is not the quantity of the Frontend tools, but their variety, diversity. For instance, there might be hundreds of auto producers. But they have priorities, advantages, and disadvantages for different countries, cultures, and different weather conditions. Some produce good cars for countries with hot weather, some produce vehicles durable in freezing cold. Some vehicles go smoothly only on plain surfaces and are very stylish, and some are all-terrain vehicles but not so stylish.

All the same, libraries have pros and cons depending on the project requirements. Some are fully compatible with “Google Chrome” or “Chrome Project” browsers, some run smoothly on “Internet Explorer”. Some are very fast to visualize but has fewer beautiful elements, others might be slower but have very attractive ready to use UI elements.

In general, the most important Frontend tools that lead the race these days are “React.js”, “Angular” and “Vue.js”.

Behind the curtains

To make developers' life easier, React.js provides us with a syntax extension called JSX. We call it “JSX — Javascript XML” otherwise. With the help of JSX, we can embed HTML code into React code.

As you can see from the picture above, you can embed HTML tags directly into the React code. All the written code then is converted to a simple HTML, CSS, and Javascript combination, with the help of a transpiler, called “Babel”.

Sum it up

If you are planning to conquer the world of Frontend, I recommend starting with one of those three leaders. Personally, I am a fan of “React.js”. But, according to ratings, job postings, and the number of developers using them, “Angular” and “Vue.js” are also on top of the hills.

One thing to note, before diving into any of them, is the learning process. The complexity of learning each of them is different. According to the analysis I have conducted, arguments noted in blogs, and some statistics, “React.js” has an easy and fast learning path.

Besides that, after learning React.js, you can easily shift to React Native. React Native also has a large user community and provides you with tools to develop cross-platform (both Android and iOS) mobile apps.

Good luck to you starting your journey in the Frontend world. Stay home, stay healthy, stay hungry for learning!

A short intro into classes in Ruby

Merdan Durdyyev — Wed, 25 Nov 2020 16:08:50 +0000

Welcome, dear friends, readers, and coders! This article will be dedicated to classes in the Ruby programming language.

OOP (Object Oriented Programming)

Before starting classes, let’s define what OOP is. In short, OOP, or Object Oriented Programming is a concept used in almost all programming languages that let us define anything in the digital world by making it resemble a real-world object. So, what does that mean?

As we all know, any object in the real-world has attributes and movements. Otherwise, the attributes of an object are its properties, and its movements are its actions or methods. This way, we can model any type of object in a digital world by providing it with real-world object features.

Let’s try to define a car:

Properties :

color
price
brand
model
manufacture date
and etc.

Methods:

start
stop
turn
accelerate
brake
and etc.

This way we defined a real-world object with its features and now we can model it in a digital world

Classes/Objects and Methods

As we mentioned earlier, we clarify its properties/attributes and actions/methods when we define objects. We have two conflicting words here. They are “Class” and “Object”.

“Class”: a drawing, a draft project of an object, a block of code defining and object.
“Object”: A working, a living model of a block of code that was defined as a “Class”.

We can compare it to preparing drafts before manufacturing a car, or preparing drawings before building a building, or writing draft notes before writing a novel itself.

Examples of classes and objects

So now, let’s define some classes and start using them as objects.

class Car

   def initialize(car_brand, car_model)
      @brand = car_brand
      @model = car_model
   end   

   def info
      puts "Car info"
      puts "Brand : " + @brand
      puts "Model : " + @model
   end   

   def start
      puts "Car was started!"
   end

   def stop
      puts "Car was stopped!"
   end

end

You can see, in the code above, that we have defined a class named “Car”, with its properties and methods.

Properties of the class are “brand” and “model”. You might have noticed that they are brought to use with the help of “initialize” method.

Besides those, we have several methods named “info”, “start”, and “stop” respectively. All of them are performing different tasks. Now, if we want to use this, we need to create an instance of the class, and it becomes a new Object:

tesla_model_s = Car.new("Tesla", "Model S")
opel_astra = Car.new("Opel", "Astra")
toyota_camry = Car.new("Toyota", "Camry")

toyota_camry.info
# "Car info"
# "Brand : Toyota"
# "Model : Camry"

opel_astra.start
# "Car was started!"

opel_astra.stop
# "Car was stopped!"

I think now it is clear what we wanted to explain earlier about classes and objects. “Car” class was put into production and several new objects were created. This means, “tesla_model_s”, “opel_astra”, “toyota_camry” are unique objects. All of them have properties of different values and methods.

“Built-in” and “User-defined” classes

In one of my previous articles about Ruby, we have mentioned built-in and user-defined functions, in an article about functions.
The same as in functions, there are built-in classes. If they are not covering our requirements, and if we need our own classes (like “Car” class), then we write our own user-defined classes.

Here are some examples of built-in classes:

String
Math
Float
Array
Time

Goodbye

Here we finalize our short article about classes and OOP in Ruby. Hundreds of pages can be written about OOP, classes, objects, and the object-oriented architecture in whole. But we restrict ourselves with the minimum written here. You can get tons of extra info on the web if you want to dive deeper. So, never stop learning. Good luck!

Functions in Ruby

Merdan Durdyyev — Tue, 24 Nov 2020 16:05:56 +0000

Welcome

Welcome back dear readers, coders, and guests! This time we are going to go through functions and how to use them in our beloved Ruby!
First of all, we have to underline that it is with the help of functions that we can reduce thousands of lines of code to maybe hundreds or tens or even less. They let us decrease code size, optimize it, and simplify.
Depending on the situation we can use so-called “built-in functions” or ”user-defined functions“. We will mainly focus on the “user-defined-functions” in this article.

What is a function?

They can be called building blocks of large programs. They let us simplify large blocks of repetitive code. By naming them correspondingly, we can call them later in any part of the program. Without them, we would have to write the same block of code many times within the program.

To cut it short, a function is a named block of code. Let’s dive a little deeper in the details:

A function has a unique name;
A function can get input data;
A function can return a value.

A function and a procedure: The word ‘function’ actually comes from maths. If we pay attention to a function in maths, they always return a result. Because of this, in earlier programming languages, some blocks of code were called “a function”, and some “a procedure”, depending on whether it returns a result or not. You can look for it in “Pascal” programming language. But in modern programming languages, the difference smoothly disappeared and now they are all called functions.

Input data: Depending on what you are trying to achieve, you sometimes need initial data to calculate something or perform some kind of operations. For instance:

You need the guest's name to say hello to him by his name;
You need monthly income and expenditure reports to find out whether the company is doing good;
You need quantity and unit prices of products to calculate weekly sale report in a store.

The same logic works in programming. You sometimes need some kind of initial data to calculate something. We call them “parameters”.

When we call a function and pass them initial data that we previously called “parameters” while defining the function, are now called “arguments”. When we list initial data while defining a function, they are called “parameters”. And when we list the initial data while calling the function, they are called “arguments”.

Output/result: As we already mentioned above, some code blocks return a result, and some don’t. We generally use “return” reserved worked (keyword) to return a result from the function.

Function Examples

We need to use the 'def' keyword to define a function in Ruby.

Now let’s see some blocks of code about how to define functions:

# No input data, no output
def say_hello
   puts "Hello Ruby"
end

say_hello()  # "Hello Ruby"

The function above does not accept input and does not return the output result. Now, let’s give it an input data:

# Gets input data but no returns no output
def say_hello(guest_name)
   puts "Hello #{guest_name}"
end

say_hello("John")  # "Hello John"

Now let’s make it accept input and return a result:

# Accepts input and returns an output
def say_hello(guest_name)
   return "Hello #{guest_name}"
end

say_hello("John")  # Nothing appears on the screen

# To display the result on the screen,
# we have to pass the output result to 
# 'puts' function
puts say_hello("John")  # "Hello John" is displayed on the screen.

As we see in the last example, ‘guest_name’ is a parameter, and ‘John’ is an argument.

Parameters/Arguments and output result

If we are providing multiple data to the function, we list them and separate them with the help of a comma. The most important part is that we have to list them in the same order when we are calling the function, as we listed them when defining the function. If we first provided the first name and then the last name, we list them in the same order when calling the function, first name, and then the last name. For example:

def say_hello(first_name, last_name, age)
   puts "Hello #{first_name} #{last_name}, You are #{age} years old"
end

say_hello("John", "Brown", 25)
# "Hello John Brown, You are 25 years old"

say_hello(18, "John", "Brown")
# "Hello 18 John, You are Brown years old"
# In this example, the argument order is wrong.

In strictly typed programming languages, together with the parameter name, you provide its type. Be it an ‘integer’, a ‘string’, a ‘character’, or a ‘boolean’, you will have to indicate it together with the parameter name. In some programming languages, a compiler warns or returns an error when the wrong type of parameters are provided to the function.

In modern programming languages like “Ruby”, “Python” and etc., you don’t have to provide types with parameter names. It’s on the shoulders of the developer to provide the right type of data to the function.

We don’t always return a result from a function. But when we do, we usually use the ‘return’ keyword. But in Ruby, the last part of the function block is returned as a result. It is surely a savior for the programmer. But not all the Ruby programmers get used to it and they continue using the ‘return’ keyword to return a result. Here is a sample code:

def print_bill(unit_price, quantity)
   return unit_price*quantity
end

# 4 items sold with price 3.5 USD.
puts print_bill(3.5, 4) 
# Output is '14.0'.

def print_bill_2(unit_price, quantity)
   "lala lala"
   unit_price*quantity
end

# 4 items with unit price 3.5 are sold.
puts print_bill_2(3.5, 4)
#  Output is '14.0'
# The last line has 'unit_price*quantity', so it is the result.

“Built-in” functions

To make developers’ life easier, all programming languages have ready to use built-in functions. With the help of them, we can write code faster. It would have been a disaster without them.

All the programming languages have built-in methods/functions for maths calculations and to operate on Strings. Let’s look at some of them:

# Make all characters capital - 'capitalize'
"hello".capitalize  # "HELLO"

# Converts data to string - 'to_s'
25.to_s  # "25"

# Returns the square root of a given number - 'sqrt'
Math.sqrt(25)  # 5

There are tons of built-in functions/methods like the ones we have just mentioned. Their number depends on the programming language. You can take a look at them on the official documentation web pages of the corresponding programming languages.

The End

Finally, we are at the end of the article about functions in Ruby. It means, later on, our code will be shorter, simpler, more productive, and more professional. It adds beauty at the same time. So, never stop learning and optimizing, refining, and refactoring your code. Move one step further by learning something new every other day. Goodbye for now. Good Luck!

Ranges in Ruby

Merdan Durdyyev — Mon, 23 Nov 2020 15:02:28 +0000

Welcome

Welcome back, dear friends! Welcome newcomers, coders, and enthusiasts! Today we are going to have a look at how to use Ranges in our beloved Ruby PL. To note first, Ranges are a data structure that is not present in many programming languages. It became popular in modern programming languages and it just represents a slice of a previously defined and ordered set of elements.

What is a Range?

We come across Ranges in many daily situations. For instance:

Month range: between “April — September”
Number range: between “5–8”
Letter range: between “d — h”

The existence of such a class releases us from the burden of creating an Array of ordered elements in some cases. If we need a slice of elements, say from 20-th to 30-th one, we don’t have to define them as Array. Listing all the required elements will take time. In the examples above, we are free from defining those letters, numbers, months, and month dates as separate Arrays. We just show the starting element and ending element and separate it as a Range.

To define Ranges, we put dots between the starting and ending elements. Here is what they mean:

(3..8): “two dots”, includes the ending element, (3, 4, 5, 6, 7, 8)
(3…8): “three dots”, does not include the ending element, (3, 4, 5, 6, 7)

Here are some examples of these:

(1..5)        #==> 1, 2, 3, 4, 5
(1...5)       #==> 1, 2, 3, 4
('a'..'d')    #==> 'a', 'b', 'c', 'd'

Create a new Range

To create a new Range we just write the starting and ending element values and put two or three dots between them. We have already covered what those dots mean in the section above. To print the Range you can use the “to_a” method. This way you convert the Range to an Array.

(-1..-5).to_a      #=> []
(-5..-1).to_a      #=> [-5, -4, -3, -2, -1]
('a'..'e').to_a    #=> ["a", "b", "c", "d", "e"]
('a'...'e').to_a   #=> ["a", "b", "c", "d"]

The interesting part of this is that you can do something like this:

range1 = ('bar'..'bav').to_a

puts "#{range1}"
# Output: ["bar", "bas", "bat", "bau", "bav"]

As you see, Ruby PL automagically understands what values to insert in between. Bravo “Ruby”!

Range methods

There are some widely used methods with Ranges. Here they are:

include? : Returns “true” or “false”. Checks whether the requested element is present in the given Range.
max: Returns the maximum element in the Range.
min: Returns the minimum element in the Range.
reverse: Reverses the Range.

Let’s see some examples of how to use them:

# 'include?' method
puts ("a".."z").include?("g")   #=> true
puts ("a".."z").include?("A")   #=> false
puts ("a".."z").include?("cc")  #=> false

digits = 0..9
puts digits.include?(5) # true

# 'max' and 'min' methods
puts (10..20).max    #=> 20
puts (10..20).min    #=> 10

# 'reverse' method
puts (1..5).to_a.reverse

# 'first' method
(10..20).first     #=> 10
(10..20).first(3)  #=> [10, 11, 12]

# 'last' method
(10..20).last      #=> 20
(10...20).last     #=> 20
(10..20).last(3)   #=> [18, 19, 20]
(10...20).last(3)  #=> [17, 18, 19]

Iterating over Range elements

As we already have seen in Arrays and Hashes, we can iterate through them using the ‘each’ method. It means we can also use that method for iterating over a Range. We can use this code snippet to print all the elements of a Range:

numbers = (15..20) 

numbers.each do |num|
  puts "Next number = #{num}"
end

# Next number = 15
# Next number = 16
# Next number = 17
# Next number = 18
# Next number = 19
# Next number = 20

Exactly the same way, you can iterate over a letter Range.

Using Ranges in conditional checks

If we take a look at how we use Ranges in conditionals, we can recognize that they are mostly used in the “case-when” conditional structure. To be precise, we check if the subject item is in between the given Range. In other programming languages, the same conditional structure is otherwise called ‘switch-case’, and using that we can only check for equality to a certain value, not an inclusion in the Range. But in Ruby, we can check if a subject value falls in the given Range. For instance:

grade = 70

result = case grade
   when 0...50 then "Sorry, you failed!"
   when 51..60 then "That was hard, but you passed!"
   when 61..70 then "Not bad!"
   when 71..80 then "Satisfactory!"
   when 81..100 then "Great, you are a Superman!"
   else "Incorrect grade !"
end

puts result

Conclusion

Dear friends, here we came to the end of the article. One thing we have to remind ourselves once more is that the “Range” class is present in not so many programming languages. This shows to what extend Ruby developers thought of software developers' comfort.
Ruby philosophy has such a point: “Developer happiness first”. This, once again underlines that Ruby is for human beings :-)
So much comfort is provided for us. So let’s learn the programming language that puts developers' happiness first.
See you in the next article. Goodbye!

Hashes in Ruby

Merdan Durdyyev — Sun, 22 Nov 2020 23:43:19 +0000

Welcome

Good day, dear friends, coders, and enthusiasts! Let’s walk through one more thing in our beloved Ruby PL. Come and learn something new and add up to our knowledge base. This time it will be Hashes and how we use them in Ruby.

What is a Hash?

The same as Arrays, Hashes are a set of elements with certain features. At a first sight, Hashes kind of resemble Arrays in some aspect. As you know, elements in Arrays each have an ordering number, i.e. index. On the other side, Hash elements have keys, that are unique for each of the Hash elements. So, each element in Hash is a pair of key and its value. Let’s take a look at the example:

Names of countries and their shortcodes (TKM=>Turkmenistan, ESP=>Spain, NZ =>New Zealand and etc.)
Word and its translation in a dictionary (cat => кошка, dog => собака and etc.)
Domain address and its IP (www.medium.com => 192.159.043.129 and etc.)

As you see in the example above, each pair is accepted as an element in Hash. If we accept the element index as part of the element in Arrays, they can now resemble Hash elements.

According to the example above:

NZ — is a key / New Zealand — is a value
cat — is a key / кошка — is a value
www.medium.com — is a key / 192.159.043.129 — is a value. and etc.

It means that, when we refer to the ‘cat’ key, we can get its value ‘кошка’. When referring to the key ‘NZ’ key, we can get its value ‘New Zealand’. We can conclude that the ordering in Hashes is not important. The important part is that the elements have unique keys and when that we can access element (pair) values by referring to the keys.

One more thing to note is that each key in a Hash must be unique. When we refer to the ‘NZ’ key, it must return its ‘New Zealand’ value.

But values can in different elements can be the same. Values do not have to be unique. For instance:

{NZ => ‘New Zealand’, NZE => ‘New Zealand’, ES => ‘Spain’, ESP => ‘Spain’, NZL => ‘New Zealand’, SPN => ‘Spain’}

What’s important is that each key must be unique, so that the Hash knows which pair we refer to when we provide a key to its element. But values can be the same in many of its elements.

Creating a new Hash element

Hashes also have special brackets. We use curly brackets to define a Hash. We also use colons to separate key and value pairs.

# An empty hash 
{}

# Smartphones and developer companies
phones = {Mi_Note_9: 'Xiao Mi', Galaxy_A5: "Samsung", Iphone_10: 'Apple', Diamond_S34: 'Samsung', Mi_Super_X: 'Xiao Mi'}

# Products and quantities
products = {monitor: 4, keyboard: 13, watch: 38, mouse: 10, door: 7}

As you see in the example above, ‘Xiao Mi’ or ‘Samsung’ companies have many phones, that is, values are the same in many elements, but the keys are all unique. So, when we refer to the unique key ‘Diamond_s34’, it returns its element ‘Samsung’.
In the example above, in each pair divided by comma, the one on the left is the key and the one on the right is the value of each element.

You can store any kind of object as a key or as a value in the Hash element.

months = Hash.new
months = {"1": "January", "2": "February", "3": "March"

Accessing and Updating Hash elements

To access elements in the Hash, we use square brackets [], as it was in Arrays. We write the key we want to get in the square brackets.

If there is such a key in the Hash, then you get its value.
If there is no such key in the Hash, then that key and its value are added to the Hash.

So let's access existing elements and add some new to the Hash.

# Fruits and prices
fruits = {ananas: 12.7, banana: 4.9}
puts fruits[:ananas]  # 12.7
puts fruits[:apple] # 'nil', because there is no such key yet

# This way we can add new element to the Hash
fruits[:apple] = 3.6
fruits[:lemon] = 5.35

# New Hash {ananas: 12.7, banana: 4.9, apple: 3.6, lemon: 5.35}
puts fruits[:lemon] # 5.35

If we want to search for a specific element in the Hash, we have two options. We can search for its key or its value. Depending on what we search for, we use corresponding methods for it. These methods return ‘true’ or ‘false’. Otherwise, they let you know whether such key or value exists in the Hash.
Here they are:

has_key?(key), key?(key) : Checks whether we have such a key in the Hash.
has_value?(value), value?(value) : Checks whether we have such a value in the Hash.

countries = {ES: 'Spain', TM: 'Turkmenistan', NZ: 'New Zealand'}
puts countries.has_key?(:ES) # true
puts countries.key?(:GB) # false
puts countries.has_value?('Turkmenistan') # true
puts countries.value?('Great Britain') # false

Length/Size of the Hash

As in Arrays, to calculate the number of elements or pairs in Hashes, we use ‘size’ and ‘length’ methods.

fruits = {ananas: 12.7, banana: 4.9, apple: 3.6, lemon: 5.35}
puts fruits.length # 4
puts fruits.size   # 4

Add or remove elements from a Hash

We already did this kind of manipulation in one of the examples above to add a new element to a Hash. If we provide a key that is not yet present in the Hash, then we automatically add it as a new value into it. We just have to define its value as well.
For instance:

countries = {ES: 'Spain', TM: 'Turkmenistan'}
puts countries[ES] # 'Spain'
countries[:NZ] = 'New Zealand'
# {ES: 'Spain', TM: 'Turkmenistan', NZ: 'New Zealand'}

We use ‘delete’ methods to remove an existing element from the Hash. We provide the key of the element to be removed as a parameter to that method.

countries = {ES: 'Spain', TM: 'Turkmenistan', NZ: 'New Zealand'}
countries.delete(:ES) # removes pair (ES: 'Spain') 
puts countries[:ES] # nil, because we already removed it.

Iterate through Hash elements

You might remember using ‘each’ method to iterate through Array elements. We can use the same methods to iterate through each pair in the Hash.
Let’s take a look at the code below that outputs each pair on a new line.

person = {name: 'John', height: 180, weight: 85, hair: 'black'} 

person.each do |key, value|   
   puts "John's #{key} = #{value}" 
end
# John's name = John
# John's height = 180
# John's weight = 85
# John's hair = black

Getting all the keys or values from the Hash

If we want to print out only the keys or only values from the Hash, then we use these methods:

keys: returns list of Hash keys
values: returns list of Hash values Let’s take a look at the currencies example:

currencies = {USA: 'USD', Turkey: 'TL', Turkmenistan: 'TMM'}
puts currencies.keys # [USA, Turkey, Turkmenistan]
puts currencies.values# ['USD', 'TL', 'TMM']

Conclusion

Hey, friends. We came to the end of the article about Hashes. So now we know a bit more about Ruby PL and one more complex data structure. You might have similarities between Arrays and Hashes and at the same time recognized that they are somewhat completely different.
You get more professional and strong in a battle, as you learn and use more tools. Sometimes I compare it to programming tools. And as we learn and use more tools, we get to write more professional code. So now we have one more tool in our set.
Let’s develop together and write clean and beautiful code. Good luck!

Arrays in Ruby

Merdan Durdyyev — Wed, 18 Nov 2020 14:59:05 +0000

Welcome

Welcome, dear readers, coders, and enthusiasts!
Here we are with our next article. To be honest, the more I write (blog), the more I learn, repeat, and get more professional. As you all know, “The best way to learn something is to teach it”. So I try to write more about what I learn and what I do. And it gives me an opportunity to revise what I have learned and nail it deeper in my mind.

So, this time we are here to learn how to use and deal with Arrays in our beloved Ruby PL.

Arrays

An array is a data structure that is present in almost all programming languages. In short, Array — is a collection of items that are placed in a certain order. You can store grades of students, product prices, product names and etc. in an Arrays. This is just an example. You can store more complex objects, data structures in an Array.

In Ruby PL, compared to some other programming languages, we can store various typed data in an Array. I.e. you can store Numeric, String, Boolean, and some other kind of complex objects. In regular programming languages, you can only store one type of object, like only String or only Number. The main point is to treat them in the given order. All items in an Array have an index number.

To summarize:

Each of the elements in an array has an index number
Indexing the elements starts with 0 (in an Array with ’n’ elements, the first element has index ‘0’, and the last element has an index number ‘n-1’)

Creating a new Array

To create a new Array it is enough to place it in square brackets. For instance:

users = []  # Empty array

users = ["Arthur", "John", "Ford"] # 3 element Array

# If the Array consists of only 'String' data
users = %w(Arthur, John, Ford)

There is another way to create an Array. It is by using the ‘Array’ keyword.

numbers = Array.new # Empty array

# Array with 3 nil elements
other_numbers = Array.new(3) # [nil, nil, nil]

# Array with defined elements
the_numbers = Array.new([15, 20, 25]) # [15, 20, 25]

# Another Array with defined numbers
five_tens = Array.new(5, 10) 
# [10, 10, 10, 10, 10]

As you can see, you can create empty Arrays and Arrays with predefined elements. If you want, you can create an Array with a defined number of elements that are all equal to a certain value, as shown in the last example.

Accessing and updating elements

As we already have noted, all of the Array elements have an index number. What we always have to keep in mind is that the numbering starts with ‘0’.

in an array with ‘5’ elements, the first element has an index ‘0’, the last element has an index number ‘4’;
in an array with ‘10’ elements, the first element has an index ‘0’, the last element has an index number ‘9’;
in an array with ‘m’ elements, first element has an index ‘0’, the last element has an index number ‘m-1’;

To access array elements we use square brackets. If we want to get the element with an index number 3 in an array named ‘grades’, we access its element using ‘grades[3]’.

seasons = ["Winter", "Sprint", "Summer", "Autumn"] # 4 elements

puts seasons[0] # The first element, with an indeks '0'
puts seasons[3] # The last element, with an index '3'

# Updating elements
seasons[0] = "Cold winter"
seasons[2] = "Hot summer"

Besides using index numbers, Ruby has made it easier and gave us built-in “first” and “last” methods. As you already have understood, these methods get you elements with indices ‘0’ and ‘n-1’.

cities = ["Boston", "Seoul", "Delhi", "Dubai"]

puts cities.first # "Boston"
puts cities.last # "Dubai"

Inserting and removing elements

We have two groups of commands to use when we want to insert and remove elements from an Array. One group methods insert and remove from the end of an Array. The other group methods insert and remove elements from the start of an Array.

Here they are:

push (insert to the end of an Array)
pop (remove from the end of an Array)
— — -
unshift (insert to the start of an Array)
shift (remove from the start of an Array)

planets = ["Mars", "Earth"]

# 'push' & 'pop' methods
planets.push "Neptune" # ["Mars", "Earth", "Neptune"]
planets.push "Saturn" # ["Mars", "Earth", "Neptune", "Saturn"]

# Remove last element (pop)
planets.pop # ["Mars", "Earth", "Neptune"]
planets.pop # ["Mars", "Earth"]

# 'unshift' & 'shift' methods
planets.unshift "Neptune" # ["Neptune", "Mars", "Earth"]
planets.unshift "Saturn" # ["Saturn", "Neptune", "Mars", "Earth"]
planets.shift # ["Neptune", "Mars", "Earth"]
planets.shift # ["Mars", "Earth"]

# delete_at
colors = ["yellow", "white", "blue", "black"]
colors.delete_at 2 
# Remove element with index '2', that is 'blue'
# ["yellow", "white, "black"]

Methods that insert new elements return a new state of the Array. Methods that remove an element from an Array, just return the removed element.

kids = ["Larry", "Brandon", "May", "John"]

first_kid = kids.shift
# first_kid => "Larry"
# kids = ["Brandon", "May", "John"]

last_kid = chagalar.pop
# last_kid=> "John"
# kids = ["Brandon", "May"]

An Array has another method to add elements to it. It is actually a short version of ‘push’ method. You can use it with “<<” symbols.

colors = ["yellow", "white"]

colors<<"blue"  # ["yellow", "white", "blue"]
colors<<"black"  # ["yellow", "white", "blue", "black"]

Size of an Array

“Ruby” PL has three methods to get the number of elements in an Array. It returns the size of the Array. Many programming languages use either of these methods. But developers of Ruby decided to include them all together. Here the are:

length
size
count
empty? (checks whether the Array is empty or not, returns “true” or “false”)

colors = ["yellow", "white", "blue", "black"]
puts colors.length # 4
puts colors.size # 4
puts colors.count # 4
puts colors.empty? # false

Iterating through Array elements

To iterate through Array elements we have two mostly used methods. They are “each” and “each_with_index” methods.

each (iterates through Array elements)
each_with_index (additionally, gives access to element index)

colors = ["yellow", "white", "blue", "black", "red"]

colors.each { |element| puts element } 
# yellow
# white
# blue
# black
# red

colors.each_with_index { |elem, index| puts "#{index} - #{elem}" } 
# 0 - yellow
# 1 - white
# 2 - blue
# 3 - black
# 4 - red

Extra methods

sort (Ordering): Used to order Array elements.
uniq (non-repeating elements): returns only non-repeating, unique elements of the Array.

numbers = [1, 7, 2, 3, 3, 6, 5, 5]

puts numbers.sort 
# [1, 2, 3, 3, 5, 5, 6, 7]

numbers = numbers.uniq
# => [1, 2, 3, 5, 6, 7]

join: joins Array elements into a single String.
split: splits “String” type element into Array elements.

letters = %w(a b c d)

puts letters.join # "abcd"

puts "a b c".split 
# ["a", "b", "c"]

Conclusion

Dear readers. Here we come to the end of the article about Ruby Arrays. Array methods are not only restricted to the ones listed here, in the article. We could have counted and written many more of them. No need to load the learner with loads at once. So if you want a bit more, just go to the documentation where you can find much more about Ruby and Arrays.
So, this is all for now. Stay hungry, stay healthy guys!

Using Modules in Ruby

Merdan Durdyyev — Tue, 10 Nov 2020 05:31:41 +0000

Welcome back dear friends, dear readers, coders, and enthusiasts!

Welcome to our next article where we present the preciousness of our beloved Ruby PL. This time we are going to look through the “Modules” topic in Ruby. We will also strengthen our learning by showing some examples of how to use Modules in Ruby.

....................................................

What are the Modules?

In short, a Module is a way to gather classes, methods, and constants under one roof. To expand the topic a bit wider, this gives us two widely used methodologies in programming.

Collection — otherwise named as a ‘namespace’, gives us an opportunity to gather classes, methods, and constants under a single roof.
Mixin — a mechanism to include a ready module into another class and use its content (methods, values, constants) as its own. Thus we can expand the possibilities of that class.

After mentioning its advantages in general, let’s dive deeper into it and look at the above-mentioned items in detail. We will also provide explanations with code examples where possible.

....................................................

1. Collection

Imagine such a situation. You decided to collect together operators, functions, and all the related data into one place. Why should we not make it a module?

module Trig
   PI = 3.1416 # A Constant  

   Trig.sin(x)
      #...
   end   

   Trig.cos(x)
      #...
   end
   ...
   ...
end

We can use the above-defined methods and constants somewhere else. Let’s use this module to perform trigonometric calculations. Here is an example:

radius = 6

# Here we call a constant named 'PI' from module 'Trig'
area = Trig.PI*radius**2 # PI*R^2 formula

# Let's calculate sine and cosine of the angle.
# Here we call 'sin' and 'cos' methods from
# 'Trig' module.

angle = 45
sine = Trig.sin(angle)
cosine = Trig.cos(angle)

If these examples are a bit easy for you, we can take a look at more complex ones. Now, let’s take a look at a module that comprises several classes in it.

You decided to develop a ‘Customer’ class. It has a few properties and methods. Depending on the context, a customer can act differently. So let’s write a class that has a bit different methods and properties depending on the type of customer in a particular situation, and place them in different modules.

module Bank
   class Customer # A bank customer.
      attr_accessor :balance, first_name, last_name

      def put_cash(sum)
         puts "#{sum} amount of cash was put."
      end      

      def withdraw(sum)
         puts "#{sum} amount was withdrawn."
      end
   end
end

module Shop
   class Customer # A shop customer
      attr_accessor :products

      def pay_for_products
         products.each do |product|
            puts "#{product} bought."
         end
      end
      ...
      ...
   end
end

I hope you paid attention to how we separated the issues and placed two different customers in two different modules. Both of the modules have ‘Customer’ class, but they behave differently. In other words, they have different methods and properties. If we have defined both classes in the same namespace, we would have had a conflict. And that would be a name conflict at least, not to mention the others. Ruby would not have allowed us to write the same-named class within the same namespace. So we just place them in different modules and no conflicts comes up.

Now we can easily call and use the ‘Customer’ class and its methods in the following examples:

# Example - 1
bank_customer = Bank::Customer.new
bank_customer.balance = 25
bank_customer.first_name = "John"
bank_customer.last_name = "Brown"
bank_customer.withdraw(50)

# Example - 2
shop_customer = Dukan::Customer.new
shop_customer.products = ["apple", "fig", "bread", "milk"]
shop_customer.pay_for_products

As you see in the examples above, by placing classes, modules, and constants into different modules we can avoid name conflicts and have them being used within the right context.

Now let’s take a look at how we can use them as Mixins.

...................................................

2. Mixins

Example A : Class relationships

There is a bit complex relationship matter called ‘inheritance’ in the programming world. It is a case when a class is a child/subclass of another one, that we call as ‘parent’. This way a child class possesses the features and methods of a parent class. Here is an example of this:

# Define a class for animals.
class Animal
   attr_accessor :name, :category  

   def make_noise
      puts 'Making noise...'
   end   

   def move
      puts 'Moving...'
   end
end

The next classes to be defined are somewhat part of, or subpart of an ‘Animal’ class. And they will possess the features and methods of an ‘Animal’ class. So, let’s define classes ‘Fish’ and ‘Bird’ and make them as child classes of an ‘Animal’ class. ‘Ruby’ PL makes it this way:

# 'Fish' class
class Fish < Animal
   ...
end

# 'Bird' class
class Bird < Animal
   ...
end

Now we can call methods of an ‘Animal’ class and use its properties from within ‘Fish’ and ‘Bird’ classes.

a_fish = Fish.new
a_fish.name = 'Ariel'
a_fish.make_noise # 'Making noise...'

a_bird = Bird.new
a_bird.name = 'Dove'
a_bird.move # 'Moving...'

Example B : Mixins

Now, getting inspired by the examples above, let’s write something a bit different. A film, an advertisement, a clip are all Videos. We can ‘play’ them and ‘pause’ them all.

Besides that, we can download them onto our PC or mobile device. Suppose we can download only video, only audio, or both at the same time. We have ‘Download’ module for this.

So let’s define ‘Video’ and ‘Download’ modules for this purpose.

# 'Video' module
module Video
   def play
      puts 'Playing ...'
   end   

   def pause
      puts 'Paused...'
   end
end

# 'Download' module
module Download
   def download_video
      puts 'Downloading only video...'
   end

   def download_audio
      puts 'Downloading only audio...'
   end   

   def download_both
      puts 'Download audio & video...'
   end
end

Now let’s define other 3 classes and make methods of ‘Video’ and ‘Download’ modules available to them.

# 'Film' class
class Film
   attr_accessor :title
   include Video
   include Download
end

# 'Advertisement' class
class Advertisement
   include Video
   include Download
end

# 'Clip' class
class Clip
   include Video
   include Download
end

Now we can use features of ‘Video’ and ‘Download’ modules after making them available within those lately defined classes. Here is an example:

# 'Film' class
silence = Film.new
silence.title= 'The Silence of Lambs'
silence.play  # 'Playing ...'
silence.download_both # Download audio and video

# 'Advertisement' class
cola_ad = Advertisement.new
cola_ad.play  # 'Playing ...'
cola_ad.download_audio # Download only audio

# 'Clip' class
drake_clip = Clip.new
drake_clip.play  # 'Playing ...'
drake_clip.download_video # Download only video

So we defined ‘Video’ and ‘Download’ as modules, and not classes. Lately, we made their features available to the other three classes. We used ‘include’ keyword for that.

Differences between Example A and Example B

The relationship between a Parent and a Child class is very important in programming. We implement it with a mechanism called ‘inheritance’ and avoid writing excess code. Thus we support DRY (Don’t Repeat Yourself).

Both ‘A’ and ‘B’ examples are doing almost the same thing but there are few differences between them. A Ruby class can not inherit from multiple classes at the same time. In other words, a class can not have multiple parent classes at the same time. So we could not inherit from ‘Video’ and ‘Download’ classes at the same time. For this reason, we implemented ‘Video’ and ‘Download’ as modules and used them as Mixins in ‘Film’, ‘Advertisement’, and ‘Clip’ classes.

.................................................

Conclusion

And now, we introduced our beloved Ruby PL closer and learned how to implement Modules in it. Besides that, we learned in which cases we should implement something as a Class or as a Module.

One of the famous modules in Ruby PL are ‘Enumerable’ and ‘Comparable’ modules. By including these modules into your custom classes, you add comparison and numerating functionality to your own classes. This way you can compare two instances of your own class and iterate through its elements if it is a type of collection.

Hope to meet you soon in the next article, dear friends.
Stay healthy, wealthy, and wise!