Ruby – Page 2

How to build a CLI Ruby Gem

Steps followed:

Planning my gem.

I would like to build a command line interface gem where I can check art exhibitions and get more info about the ones I liked.

How it would work:

– User types “exhibitions”.

– And ‘Artify’ will show a list of exhibitions like this:

Exhibition title – where

dates

-Which exhibition do you want to learn more about?

-And it will display more info about the exhibition selected.

Walkthrough video

Artify Environment

Setting my own environment: Visual Studio Code, Git and Bundler

First, I create a repository in Github.

Then, I create a new folder in my laptop where I want to clone the repository.

I open this folder in my VS code and open the terminal (ctrl + `).

I run: git clone + the https from the repository.

When I make changes:

First, I stage this changes.

Second, I write commit message and commit.

Third, I push my changes.

Installing Bundler

First I make sure I have the latest version of RubyGems. I run in the VS code terminal $gem update –system

Then I instal Bundler: gem install bundler but I got an error message

I don’t have write permissions. I googled this error output and I am trying something I found in stack overflow: sudo gem install bundler. I gave the personal password for my computer and it worked!

The purpose of sudo is to execute the command given to it with root privileges.

Adding Gems to gemfile

I created a new file gemfile and I am adding my gems to it, bundler.

‘~> 2.0’

~> is called “Twiddle-Wakka.” '~> 2.0' means any minor version above 2.0, 2.1, 2.2, 2.3 … and 2.9 included would work (including patches); but version 3.0 wouldn’t work because it indicates a new major version.

The second specification '>= 2.0.1'means any version greater than or equal to 2.0.1. Both specifications have to be true, so this gem couldn’t use version 2.0because it’s lower than 2.0.1.

My Gemfile.lock file

I run in the VS code terminal $bundle installAutomatically a file was created in my directory: Gemfile.lock

Reviewing my installed gems

I run in the VS code terminal $gem list

Checking where my Bundler is

I run in the VS code terminal $bundle show [bundler]

Adding Gemfile and Gemfile.lock to my repository

I run in the VS code terminal $git add Gemfile Gemfile.lock.

I could staged the changes in my VS code, they do the same thing that the git add command.

I check my Github repository….and it didn’t work.

Ok! I forgot to push my changes, so I ran: $git push origin master

Done! I got my two new files in my repository.

Now, I want to install Nokogiri

Installing Nokogiri

I run in the VS code terminal $sudo gem install nokogiri

And after the installation was successfully I add my new gem to the Gemfile

I check if my changes are in Github and…no! They are not! Why? BecauseI forgot to push them.

My work flow in VSC:

Save changes – stage changes – commit changes – push changes

Installing pry

I run in the VS code terminal $sudo gem install pry

And then I add the new gem to the Gemfile

And I don’t forget about my VSC workflow! Save, stage, commit and push.

Installing ‘open-uri’

I was trying to install it and got this error:

I googled it and…

OpenUri is part of Ruby standard library, I just need to require it.

After all this installations I checked my Gemfile.lock and I couldn’t see anything about nokogiri or pry. I run $bundle install and my Gemfile.lock is updated.

Installing ‘colorize’

I run in the VS code terminal $sudo gem install colorize

I add my new gem to the Gemfile.

And run $bundle install to update my Gemfile.lock.

I open my Gemfile and do this with my pry gem:

This is Group Syntax and I am specifying the environment where it is going to be used pry. I am going to change it for a shorter syntax, the hash syntax: gem ‘pry’, :group => :development

After installing all my gems I need to require them where I am going to use them.

config/environment.rb

Now, I create a folder config and a file environment.rb inside. In this file I will be loading, requiring, all of my app’s dependencies like my gems.

With this code all the gems that are inside Gemfile are required.

I need to require ‘open-uri’ and ‘colorize’ too in my environment.

What I have learned so far about OO Ruby

From what I’ve understood Object-Oriented programming is very popular and it has lots of advantages. The programmer may have a closer feeling of working with real-life entities due to the multitask nature of the objects in OOP. From my point of view OOP is a good way to keep all your code organise. Each object contains its data and functionality within its scope and if its methods are written in an abstract way they can be reused for other objects or for a different project.

I am still working in the OO Ruby section and it is taking me some time to understand all the concepts and why or when to use them. Here it is what I have learned so far:

Creating a class

Class names begin with capital letters because they are stored in Ruby constants. If our class name contains two words, the name should be CamelCased.

class Dog

end

class Dog

end

Instantiation

Every time we want to represent a new individual in our program we should instantiate an object of that type (Dog.new). We call these individuals instances.

class Dog

end

flecha = Dog.new
flecha #=> #<Dog:0x007fc52c2d7d20> #This is the object identifier, Ruby Object Notation.

class Dog

end

flecha = Dog.new

flecha #=> #<Dog:0x007fc52c2d7d20> #This is the object identifier, Ruby Object Notation.

Instances variables

An instance variable represents a singular property of an individual, of an instance. This variable is accessible in any instance method in a particular instance of a class. The name of the instance variable is written with a @ at the beginning of the word: @instance_variable_name.

class Dog
  def name=(name)
    #This is the instance variable
    @name = name
  end
  
  def name
    @name
  end
end
  
flecha = Dog.new #We create an instance of Dog
flecha.name = "flecha" #We set the name of this new instance to "flecha"

class Dog

def name=(name)

#This is the instance variable

@name = name

end

def name

@name

end

flecha = Dog.new #We create an instance of Dog

flecha.name = "flecha" #We set the name of this new instance to "flecha"

Instance methods

We call the methods defined within the object’s class instance methods because they are methods that belong to any instance of the class.

They provide a mechanism for an object to expose to the outside world its data. They can manipulate the internal state of an object and provide some functionality for an individual object too.

class Dog
  # Class body

  # Instance Method Definition
  def bark
    puts "Woof!"
  end
end
  
flecha = Dog.new
flecha.bark #> "Woof!" #Now flecha can bark

class Dog

# Class body

# Instance Method Definition

def bark

puts "Woof!"

end

flecha = Dog.new

flecha.bark #> "Woof!" #Now flecha can bark

Attribute readers, writers and accesors

Our object’s instances can have attributes, like a name or hair colour in the case of our Dog class. In order to set these attributes we have to use a writer and in order to have these data available in the outside world we have to have a reader. It is very important to use an instance variable (@name), otherwise the getter method couldn’t read the data that we set in the writer method because it is out of scope.

class Dog
  
  def name=(name)#This is the setter or writer method 
    @name = name
  end
 
  def name #This is the getter or reader method
    @name
  end
end

class Dog

def name=(name)#This is the setter or writer method

@name = name

end

def name #This is the getter or reader method

@name

end

This is the explicit method for the attribute @name. There is another faster way to do it using a macro: the attr_writer, the attr_reader and the attr_accessor that does the work of the two previous macros. In Ruby a macro is like a method that instead of returning a Ruby datatype returns more Ruby code. The implementation of macros is considered metaprogramming.

class Dog

  attr_writer :name #This is the setter method
  attr_reader :name #This is the getter method
  
end

#This snippet is equal to the following one:

class Dog

  attr_accessor :name
  
end

class Dog

attr_writer :name #This is the setter method

attr_reader :name #This is the getter method

end

#This snippet is equal to the following one:

class Dog

attr_accessor :name

end

When to use attr_accessor vs a custom reader/writer.

The attr_accessor macro will provide a naive interface for reading and writing to an instance variable. Anytime we need something conceptually different or more complex, we should build our own reader or writer.

Self

Whenever an object needs to refer to itself, the keyword “self” is used.

In an instance method, self will always refer to the instance itself and in a class method, self will always refer to the class itself.

Class variable

Class variables are for properties that belong to the entire class. A class level variable can be used for example for instance memoization, for keeping track of all instances of a class or for collaborating data. The name of the class variable is written with a double @ at the beginning of the word: @@class_variable_name.

class Dog
  attr_accessor :name
  @@all = [] #This is a class variable
 
  def self.all
    @@all
  end
end

class Dog

attr_accessor :name

@@all = [] #This is a class variable

def self.all

@@all

end

#self.all is a class method for reading data stored in the class variable @@all. This is a class reader, very similar to an instance reader method that reads an instance property.

Class methods

With these methods we can access any class variable. A class method operate on the entire class and expose the class’ scope to the rest of our program. They don’t have access to the instance scope.

def self.class_method_name
  # some code
end

def self.class_method_name

# some code

end

The most common class methods are:

Class finders

A class finder method returns existing instances.

class Dog
  attr_accessor :name
  @@all = []
  
  def initialize(name)
    @name = name
    self.class.all << self
    # self in the initialize method is our new instance
    # self.class is Dog
    # self.class.all == Dog.all

  end
 
  def self.all
    @@all
  end
  
  def self.find_by_name(name) #This is the class finder
    self.all.find{|dog| dog.name == name}
  end

end

class Dog

attr_accessor :name

@@all = []

def initialize(name)

@name = name

self.class.all << self

# self in the initialize method is our new instance

# self.class is Dog

# self.class.all == Dog.all

end

def self.all

@@all

end

def self.find_by_name(name) #This is the class finder

self.all.find{|dog| dog.name == name}

end

Custom class constructors

A class constructor is any class method that instantiates an instance of the class.

class Dog
  @@all = []

  def self.create
    @@all << self.new
  end
end

class Dog

@@all = []

def self.create

@@all << self.new

end

Class operators

A class operator is perfect to manipulate any class level data.

class Dog
  attr_accessor :name
  @@all = []
 
  def self.all
    @@all
  end
  
  def initialize(name)
    @name = name
    @@all << self
  end
  
  def self.destroy_all
    self.all.clear
  end
end

class Dog

attr_accessor :name

@@all = []

def self.all

@@all

end

def initialize(name)

@name = name

@@all << self

end

def self.destroy_all

self.all.clear

end

Programming paradigms

A programmer can follow different approaches, also known as programming paradigms, when writing code. Two of the most important programming paradigms are the procedural and the Object-Oriented ones.

Usually a programming language falls under one paradigm like Ruby , that is mainly an OOP language. But some other languages as JavaScript can be multi-paradigm and support procedural, object-oriented (prototype-based) and functional programming styles.

The main difference between them is how you organise your code:

-In a procedural approach your code is a list of instructions or steps to be carried out.

board = Array.new(9, " ")

puts "Welcome to Tic Tac Toe!"
display_board(board)

play(board)

WIN_COMBINATIONS = [
  [0,1,2], # Top row
  [3,4,5], # Middle row
  [6,7,8], # Lower row
  [0,3,6], # Left column
  [1,4,7], # Middle column
  [2,5,8], # Rigth column
  [0,4,8], # Left to Rigth diagonal
  [2,4,6] # Rigth to Left diagonal
]

# Display_board accepts a board and prints
# out the current state.
def display_board (board)
  puts " #{board[0]} | #{board[1]} | #{board[2]} "
  puts "-----------"
  puts " #{board[3]} | #{board[4]} | #{board[5]} "
  puts "-----------"
  puts " #{board[6]} | #{board[7]} | #{board[8]} "
end

def input_to_index(user_input)
  user_input.to_i - 1
end

board = Array.new(9, " ")

puts "Welcome to Tic Tac Toe!"

display_board(board)

play(board)

WIN_COMBINATIONS = [

[0,1,2], # Top row

[3,4,5], # Middle row

[6,7,8], # Lower row

[0,3,6], # Left column

[1,4,7], # Middle column

[2,5,8], # Rigth column

[0,4,8], # Left to Rigth diagonal

[2,4,6] # Rigth to Left diagonal

]

# Display_board accepts a board and prints

# out the current state.

def display_board (board)

puts " #{board[0]} | #{board[1]} | #{board[2]} "

puts "-----------"

puts " #{board[3]} | #{board[4]} | #{board[5]} "

puts "-----------"

puts " #{board[6]} | #{board[7]} | #{board[8]} "

end

def input_to_index(user_input)

user_input.to_i - 1

end

-In an Object-Oriented approach your code is organised using objects and classes.

class TicTacToe
  def initialize(board = nil)
    @board = board || Array.new(9, " ")
  end
  
  WIN_COMBINATIONS = [
  [0,1,2], # Top row
  [3,4,5], # Middle row
  [6,7,8], # Lower row
  [0,3,6], # Left column
  [1,4,7], # Middle column
  [2,5,8], # Rigth column
  [0,4,8], # Left to Rigth diagonal
  [2,4,6] # Rigth to Left diagonal
  ]

  def display_board
  puts " #{@board[0]} | #{@board[1]} | #{@board[2]} "
  puts "-----------"
  puts " #{@board[3]} | #{@board[4]} | #{@board[5]} "
  puts "-----------"
  puts " #{@board[6]} | #{@board[7]} | #{@board[8]} "
  end
  
  def input_to_index(user_input)
  user_input.to_i - 1
  end

class TicTacToe

def initialize(board = nil)

@board = board || Array.new(9, " ")

end

WIN_COMBINATIONS = [

[0,1,2], # Top row

[3,4,5], # Middle row

[6,7,8], # Lower row

[0,3,6], # Left column

[1,4,7], # Middle column

[2,5,8], # Rigth column

[0,4,8], # Left to Rigth diagonal

[2,4,6] # Rigth to Left diagonal

]

def display_board

puts " #{@board[0]} | #{@board[1]} | #{@board[2]} "

puts "-----------"

puts " #{@board[3]} | #{@board[4]} | #{@board[5]} "

puts "-----------"

puts " #{@board[6]} | #{@board[7]} | #{@board[8]} "

end

def input_to_index(user_input)

user_input.to_i - 1

end

Reading about the different paradigms I found lots of new and very complicated concepts as: modularisation as a main trait of the procedural paradigm, and data abstraction, encapsulation, polymorphism, inheritance and serialisation-marshalling as traits for the Object-Oriented paradigm.

Apart from the desire to look the other way, I decided create some short and easy to understand definitions. Maybe the next time I find these concepts I don’t feel so uncomfortable!

Modularisation: It is used for reducing the complexity of a system subdividing a computer program into modules or separate software components.
Data abstraction: It is the reduction of data to a simplified representation of the whole. In OOP the programmer would just keep the relevant data inside the object hiding everything else. Data hiding is a software development technique.
Encapsulation : It is the inclusion within an object of all the data and methods need for the object to function.
Polymorphism: It is the ability to present the same interface (Shape) for differing data types (square, circle, etc).
Inheritance: It enables new objects (subclasses or derived classes) to take on the properties of existing objects (superclasses or base classes).
Serialisation and marshalling: Both are for transforming objects into series of bits. In particular, marshalling is about getting parameters from here to there, while serialisation is about copying structured data to or from a primitive form such as a byte stream. What is byte stream? A sequence of bits. What is a bit? It is the smallest unit of data in a computer. And what am I doing right now? Yak shaving!

Css Yak GIF from Css GIFs