Forem: Ankit Pariyar

Conditional CSS Classes in Rails with class_names

Ankit Pariyar — Mon, 30 Sep 2024 14:16:09 +0000

Managing dynamic CSS classes in Rails views can get messy with string concatenation and conditional logic. The class_names method, simplifies this by letting you conditionally build class lists in a clean, readable way.

class_names("btn", "btn-primary", { "btn-disabled": disabled? })

If disabled? is true, this outputs:

class="btn btn-primary btn-disabled"

Otherwise, it excludes the "btn-disabled" class. This eliminates messy conditionals, making your views easier to read and maintain.

Set up RSpec, Shoulda matchers and FactoryBot on Rails 7

Ankit Pariyar — Wed, 24 Jan 2024 13:13:26 +0000

Rspec

Add rspec-rails on development and test group of Gemfile
```
group :development, :test do
  gem 'rspec-rails'
end
```
- Then install it with command bundle install
Run command rails generate rspec:install for generating boilerplate config files. you can see following outputs:
```
create  .rspec
create  spec
create  spec/spec_helper.rb
create  spec/rails_helper.rb
```

Verify RSpec is correctly installed and configured by running bundle exec rspec you should see following outputs:

No examples found.
Finished in 0.0002 seconds (files took 0.0351 seconds to
load)
0 examples, 0 failures

Shoulda Matchers

Shoulda Matchers provides useful one-liners for common tests.
Add shoulda-matchers to test group of Gemfile
```
group :test do
  gem 'shoulda-matchers'
end
```
- Then install it with command bundle install

To integrate it to spec add following to bottom of the rails_helper.rb

Shoulda::Matchers.configure do |config|
  config.integrate do |with|
    with.test_framework :rspec
    with.library :rails
  end
end

FactoryBot

Add factory_bot_rails to Gemfile. We want this gem to available on all rails environments, add this gem on outside of any group blocks.
```
gem 'factory_bot_rails'
```
- Then install it with command bundle install
To use FactoryBot inside the spec file require it in spec_helper.rb file
```
require 'factory_bot_rails'
```
Then in same file, inside of RSpec.configure block add following line to use FactoryBot methods without FactoryBot namespace. For example we have to do FactoryBot.create we can instead just use the create method directly
```
config.include FactoryBot::Syntax::Methods
```
we want Rails model generator to use FactoryBot to create factory file stubs whenever we generate a new model. For this, require FactoryBot on the top of config/application.rb
```
require 'factory_bot_rails'
```

Then in the same file add following code inside the Application class

config.generators do |g|
  g.test_framework :rspec, fixture: true
  g.fixture_replacement :factory_bot, dir: 'spec/factories'
end

Now RSpec, Shoulda Matchers, and FactoryBot are all set up and ready to help test your Rails application!

Doubly Linked List Implementation in Ruby

Ankit Pariyar — Wed, 09 Aug 2023 15:29:40 +0000

1. Understanding Doubly Linked List
2. Implementation of Doubly Linked List

2.1. print_list method

2.2. append method

2.3. pop method

2.4. Prepend Method

2.5. Shift Method

2.6. Get Method

2.7. set_value Method

2.8. Insert Method

2.9. Remove Method

2.10. Reverse method

github repo: https://github.com/TheZero0-ctrl/leetcode-practice

Understanding Doubly Linked List

A Doubly Linked List is a data structure that consists of a sequence of nodes, where each node contains a value and two pointers, one pointing to the previous node and the other pointing to the next node. This allows for efficient insertion and deletion operations at both the beginning and end of the list, unlike a singly linked list.

Implementation of Doubly Linked List

we will explore a Ruby implementation of a Doubly Linked List using two classes: DoublyLinkedList and Node. We will discuss each method along with their time complexities.
Here is the code for Node and DoublyLinkedList classes



class DoublyLinkedList
  attr_accessor :head, :tail, :length

  def initialize(value)
    new_node = Node.new(value)
    @head = new_node
    @tail = new_node
    @length = 1
  end

  # Other methods...
end

class Node
  attr_accessor :value, :next, :prev

  def initialize(value)
    @value = value
    @next = nil
    @prev = nil
  end
end

Only different with linked list is that Node not only have next pointer but also prev pointer

`print_list` method

It is same as print_list method of linked list



def print_list
  temp = head
  while temp
    puts temp.value
    temp = temp.next
  end
end

`append` method



def append(value)
  new_node = Node.new(value)
  if @head
    new_node.prev = @tail
    @tail.next = new_node
  else
    @head = new_node
  end

  @tail = new_node
  @length += 1
  true
end

The append method adds a new node with the given value to the end of the list.
It creates a new node and updates the prev and next pointers accordingly.
If the list is empty, the new node becomes both the head and the tail.
The length of the list is incremented by 1.
Time Complexity: O(1)

`pop` method



def pop
  return nil if @length.zero?

  temp = @tail
  @tail = temp.prev
  @tail.next = nil
  temp.prev = nil
  @length -= 1

  return temp unless @length.zero?

  @head = nil
  @tail = nil

  temp
end

The pop method removes the last node (tail) from the doubly linked list and returns it.
If the list is empty (length is zero), it returns nil.
The tail node is stored in the temp variable.
The tail pointer is updated to point to the previous node of the current tail, and the next pointer of the new tail is set to nil.
The prev pointer of the removed node is set to nil, effectively disconnecting it from the list.
The length of the list is decremented.
If the list becomes empty after the removal, both the head and tail pointers are set to nil.
Time Complexity: O(1)

`Prepend` Method



def prepend(value)
  new_node = Node.new(value)
  if @length.zero?
    @head = new_node
    @tail = new_node
  else
    new_node.next = @head
    @head.prev = new_node
    @head = new_node
  end

  @length += 1
  true
end

The prepend method adds a new node with the given value at the beginning of the doubly linked list.
It creates a new node using the input value.
If the list is empty (@length is zero), the new node becomes both the head and the tail.
If the list is not empty, the new node is added before the current head node, and the head's prev pointer is set to the new node.
The head pointer is updated to point to the new node, and the length of the list is incremented.
Time Complexity: O(1)

`Shift Method`



def shift
  return nil if @length.zero?

  temp = @head
  @head = temp.next
  @head.prev = nil
  temp.next = nil
  @length -= 1

  return temp unless @length.zero?

  @head = nil
  @tail = nil

  temp
end

The shift method removes the first node (head) from the doubly linked list and returns it.
If the list is empty (length is zero), it returns nil.
The head node is stored in the temp variable.
The head pointer is updated to point to the next node of the current head, and the prev pointer of the new head is set to nil.
The next pointer of the removed node is set to nil, effectively disconnecting it from the list.
The length of the list is decremented.
If the list becomes empty after the removal, both the head and tail pointers are set to nil.
Time Complexity: O(1)

`Get` Method



def get(index)
  return if index >= @length || index.negative?

  if index < @length / 2
    temp = @head
    (0...index).each do |_i|
      temp = temp.next
    end
  else
    temp = @tail
    (index...@length - 1).each do |_i|
      temp = temp.prev
    end
  end
  temp
end

The get method retrieves the node at the specified index in the doubly linked list.
If the index is out of bounds (negative or greater than or equal to the list length), it returns nil.
To optimize the search, it chooses to start from either the head or the tail, depending on the index's position relative to the midpoint of the list.
If the index is closer to the head (less than half the length), it starts from the head and traverses forward to find the desired node.
If the index is closer to the tail (more than half the length), it starts from the tail and traverses backward to find the desired node.
Time Complexity: O(n)

`set_value` Method



def set_value(index, value)
  temp = get(index)

  if temp
    temp.value = value
    true
  else
    false
  end
end

The set_value method updates the value of the node at the specified index in the doubly linked list.
It uses the get method to retrieve the node at the given index.
If the node is found, its value is updated with the input value, and the method returns true.
If the index is out of bounds and the node is not found, it returns false.
Time Complexity: O(n) - The time complexity of the set_value method depends on the time complexity of the get method, which is O(n).

`Insert` Method



def insert(index, value)
  return if index >= @length || index.negative?

  return prepend(value) if index.zero?

  return append(value) if index == @length - 1

  new_node = Node.new(value)
  before = get(index - 1)
  after = before.next

  new_node.prev = before
  new_node.next = after

  before.next = new_node
  after.prev = new_node

  @length += 1
  true
end

The insert method adds a new node with the given value at the specified index in the doubly linked list.
If the index is out of bounds (negative or greater than or equal to the list length), it returns nil.
If the index is zero, the method prepends the new node to the beginning of the list using the prepend method.
If the index is equal to the length of the list minus one, the method appends the new node to the end of the list using the append method.
Otherwise, a new node is created and inserted between the nodes at the index - 1 (before) and index (after).
The prev and next pointers of the new node and the adjacent nodes are adjusted to insert the new node into the list.
Time Complexity: O(n)

`Remove` Method



def remove(index)
  return if index >= @length || index.negative?

  return shift if index.zero?

  return pop if index == @length - 1

  temp = get(index)
  before = temp.prev
  after = temp.next

  before.next = after
  after.prev = before

  temp.next = nil
  temp.prev = nil

  @length -= 1
  temp
end

The remove method removes the node at the specified index from the doubly linked list and returns it.
If the index is out of bounds (negative or greater than or equal to the list length), it returns nil.
If the index is zero, the method removes the first node from the list using the shift method.
If the index is equal to the length of the list minus one, the method removes the last node from the list using the pop method.
Otherwise, it retrieves the node at the specified index using the get method and removes it from the list.
The prev and next pointers of the adjacent nodes are adjusted to disconnect the removed node from the list.
Time Complexity: O(n)

`Reverse` method



def reverse
  temp = @head
  while temp
    temp.next, temp.prev = temp.prev, temp.next
    temp = temp.prev
  end

  @head, @tail = @tail, @head
end

The reverse method is used to reverse the order of nodes
it does this by traversing through the list, and for each node, it swaps the next and prev pointers.
Finally, it updates the head and tail pointers to reflect the new head and tail of the reversed list.
Time Complexity: O(n)

Introduction to Time Complexity with ruby

Ankit Pariyar — Sun, 16 Jul 2023 13:47:15 +0000

1. Some terms

1.1. Time complexity

1.2. Space complexity

1.3. Worst/Best/Average
2. Rules for calculating Big O
3. O(n)
4. O(n^2)
5. O(log n)
6. When we have to loop through two inputs

Big O notation is a way to describe the efficiency of algorithms in terms of time and space complexity. It helps programmers understand how an algorithm's performance changes as the input size increases. It provides a concise notation to compare and analyze algorithms based on their scalability.

Some terms

Time complexity

The time complexity of an algorithm is the number of steps it takes to complete its task
measure how much time code will take
Time complexity refers to the measurement of the amount of time an algorithm takes to run, as the input size increases. It helps determine how the algorithm's execution time grows relative to the input size.

Space complexity

measure how much memory code will take
Space complexity refers to the measurement of the amount of memory or space, an algorithm requires to run, as the input size increases. It helps determine how the algorithm's memory usage grows relative to the input size.

Worst/Best/Average

"O" (pronounced "big O"): Represents the upper bound or worst-case scenario
"Ω" (pronounced "big omega"): Represents the lower bound or best-case scenario
"θ" (pronounced "theta"): Represents the average-case scenario

All the things describe below are for Time complexity

Rules for calculating Big O

Worst Case: When calculating the Big O notation, we focus on the worst-case scenario
Remove Constants: We ignore constants or coefficients, as they have a minimal impact on the overall growth rate.

def findMax(array)
  max = array[0]                  # Constant time O(1)
  array.each do |element|        # O(n)
    if element > max
      max = element
    end
  end
  return max
end

In this example, we have a function findMax that takes an array as input and returns the maximum element. Let's apply the Big O rules:

Worst Case: The worst-case scenario occurs when the maximum element is located at the end of the array, requiring us to iterate through all elements.
Remove Constants: The constant time operation of assigning max = array[0] is insignificant compared to the iterative loop.

Thus, the time complexity of the findMax function is O(n) according to Big O notation.

Drop Non Dominants

def print_pairs_and_elements(array)
  array.each do |element|
    puts element
  end

  array.each do |outer_element|
    array.each do |inner_element|
      puts "#{outer_element}, #{inner_element}"
    end
  end
end

In this example, the print_pairs_and_elements function takes an array as input. It first iterates over the array once in the first each loop and prints each element. This portion of the code has a time complexity of O(n) since it scales linearly with the size of the input array.

Following that, the function has nested each loops that iterate over the array twice. For each element in the outer loop, it iterates through the entire array in the inner loop and prints out the pair of elements. This portion of the code has a time complexity of O(n^2) since it scales quadratically with the size of the input array so this function will have time complexity of O(n^2 + n)

When analyzing the overall time complexity, we drop the non-dominant term, which is O(n) in this case. This is because, as the input size increases, the quadratic term O(n^2) will dominate the overall performance.

Therefore, we simplify the time complexity to O(n^2) because the quadratic term has a greater impact on the efficiency of the function compared to the linear term.

O(n)

represents a linear time complexity, where the execution time of an algorithm grows linearly with the input size

def linear_search(array, target)
  array.each do |element|
    return true if element == target
  end
  return false
end

In this example, the linear_search function takes an array and a target value as inputs. It iterates over each element in the array and checks if it matches the target value. If a match is found, it returns true; otherwise, it continues to the next element. If the entire array is traversed without finding a match, it returns false.

The time complexity of this algorithm is O(n) because the number of iterations directly depends on the size of the input array. As the array grows larger, the execution time of the algorithm will roughly increase in a linear fashion.

Another example

def print_twice(array)
  array.each do |element|
    puts element
  end

  array.each do |element|
    puts element
  end
end

In this example, the print_twice function takes an array as input. It iterates over the array twice using separate each loops and prints each element twice. As a result, the number of iterations is directly proportional to the size of the array.

When analyzing the time complexity, we can observe that the algorithm performs two iterations over the array, resulting in O(2n). However, in Big O notation, we drop the constant factor, so the time complexity simplifies to O(n). This is because the growth rate of the algorithm is ultimately determined by the input size, not by the specific constant factor.

O(n^2)

representing quadratic time complexity

def print_pairs(array)
  array.each do |outer_element|
    array.each do |inner_element|
      puts "#{outer_element}, #{inner_element}"
    end
  end
end

In this example, the print_pairs function takes an array as input. It uses nested each loops to iterate over the array twice. For each element in the outer loop, it iterates over the array again in the inner loop and prints out the pair of elements.

The total number of iterations in this algorithm is directly proportional to the square of the input size. If the array has 'n' elements, then the number of iterations will be approximately n * n, resulting in O(n^2) time complexity.

O(log n)

representing logarithmic time complexity

def binary_search(array, target)
  low = 0
  high = array.length - 1

  while low <= high
    mid = (low + high) / 2
    if array[mid] == target
      return true
    elsif array[mid] < target
      low = mid + 1
    else
      high = mid - 1
    end
  end

  return false
end

In this example, the binary_search function takes a sorted array and a target value as inputs. It performs a binary search algorithm to find the target value within the array.

The binary search algorithm divides the search space in half at each step. It compares the middle element of the current range with the target value and narrows down the search to the left or right half accordingly. This process continues until the target value is found or the search space is exhausted.

The number of iterations required in the binary search algorithm grows logarithmically with the input size. As each iteration reduces the search space by half, the algorithm achieves a time complexity of O(log n), where 'n' represents the size of the input array.

Logarithmic time complexity indicates that the algorithm's efficiency improves significantly as the input size increases. It demonstrates the advantage of divide-and-conquer strategies in reducing the search space efficiently.

When we have to loop through two inputs

Suppose we have a function that takes two arrays of sizes n and m as inputs and performs some operations on them. The time complexity of this function can be expressed as O(f(n, m)), where f represents the growth rate of the algorithm with respect to both n and m.

To determine the overall time complexity, we consider the dominant factors impacting the algorithm's performance. Here are a few scenarios:

Independent Operations: If the algorithm performs independent operations on the two input arrays, the time complexity is determined by the larger of the two inputs. In this case, the time complexity can be simplified to O(max(n, m)).
Nested Loops: If the algorithm uses nested loops, with one loop dependent on the size of n and the other dependent on the size of m, the time complexity can be expressed as O(n * m).
Sequential Operations: If the algorithm performs sequential operations, where the operations on the second array depend on the results of the operations on the first array, we sum the time complexities of each operation. The overall time complexity is determined by the dominant term. For example, if the first operation is O(n) and the second operation is O(m), the overall time complexity is O(n + m).

Linked List with Ruby

Ankit Pariyar — Sun, 02 Jul 2023 16:32:37 +0000

1. Understanding Linked Lists
2. Implementing a Linked List in Ruby

2.1. print_list method

2.2. append Method

2.3. pop Method

2.4. prepend Method

2.5. shift Method

2.6. get method

2.7. set_value method

2.8. insert method

2.9. reverse Method

github repo: https://github.com/TheZero0-ctrl/leetcode-practice

Understanding Linked Lists

A linked list is a collection of nodes where each node contains a value and a reference to the next node in the sequence. The first node is called the head, and the last node is called the tail. The tail node's reference points to nil, indicating the end of the list.

In this blog post, we will explore a simple implementation of a linked list in Ruby and discuss each method along with its time complexity.

Implementing a Linked List in Ruby

Let's start by examining the provided Ruby code that implements a linked list. The LinkedList class represents the linked list, and each node is represented by the Node class.

class LinkedList
  attr_accessor :head, :tail, :length

  def initialize(value)
    new_node = Node.new(value)
    @head = new_node
    @tail = new_node
    @length = 1
  end

  # Other methods...
end

class Node
  attr_accessor :value, :next

  def initialize(value)
    @value = value
    @next = nil
  end
end

The initialize method is the constructor of the LinkedList class and Node class.
It creates a new instance of the linked list with an initial value and a new instance of the node.
When a new node is created, its value will be the provided value, and the next node will be nil.
When a new linked list is created, it creates a new node object with the given value.
This node is set as both the head and tail of the linked list.
The length attribute is initialized to 1 since there is only one node in the list at the beginning.

`print_list` method

The print_list method iterates through the linked list and prints the value of each node.

def print_list
  temp = head
  while temp
    puts temp.value
    temp = temp.next
  end
end

Starting from the head node, the method iterates through the list by following the next reference of each node.
It prints the value of each node and continues until it reaches the end of the list (when temp becomes nil).
The time complexity of the print_list method is O(n), where n is the length of the linked list.
It needs to visit each node once to print its value.

`append` Method

The append method adds a new node with the given value at the end of the linked list.

def append(value)
  new_node = Node.new(value)
  if @head
    @tail.next = new_node
    @tail = new_node
  else
    @tail = new_node
    @head = new_node
  end
  @length += 1
  true
end

First, a new node is created with the provided value.
If the linked list is not empty (the @head node exists), the next reference of the current tail node is set to the new node, and the tail is updated to the new node. This way, the new node becomes the new tail.
If the linked list is empty, both the head and tail are set to the new node.
At last, we increment length by one
The time complexity of the append method is O(1) since it performs a constant number of operations regardless of the size of the linked list. It directly accesses and updates the tail node.

`pop` Method

The pop method removes and returns the last node from the linked list.

def pop
  return if @length.zero?

  temp = @head
  pre = @head

  while temp.next
    pre = temp
    temp = temp.next
  end

  @tail = pre
  @tail.next = nil

  @length -= 1

  return temp unless @length.zero?

  @head = nil
  @tail = nil

  temp
end

To remove the last node, the method iterates through the list until it reaches the second-to-last node.
The pre variable keeps track of the previous node while the temp variable moves forward.
After reaching the last node, it updates the tail to the second-to-last node, removes the reference to the last node, and decrements the length of the list.
If the list becomes empty after removing the last node, both the head and tail are set to nil.
The time complexity of the pop method is O(n), where n is the length of the linked list.
It needs to traverse the list to reach the second-to-last node for removal.

`prepend` Method

The prepend method adds a new node with the given value at the beginning of the linked list.

def prepend(value)
  new_node = Node.new(value)
  new_node.next = @head
  @head = new_node
  @tail = new_node if @length.zero?
  @length += 1
  true
end

First, a new node is created with the provided value.
The next reference of the new node is set to the current head node.
Then, the head is updated to the new node.
If the linked list was initially empty (length was zero), the tail is also set to the new node since it is the only node in the list.
At last, we increment length by one
The time complexity of the prepend method is O(1) since it performs a constant number of operations regardless of the size of the linked list.
It directly accesses and updates the head node.

`shift` Method

The shift method removes and returns the first node from the linked list.

def shift
  return if @length.zero?

  temp = @head
  @head = temp.next
  temp.next = nil
  @tail = nil if @length == 1
  @length -= 1
  temp
end

The method removes the head node by updating the head to its next node.
It also updates the next reference of the removed node to nil to detach it from the list.
If the list becomes empty after removal (length was initially one), the tail is set to nil.
At last, we decrement length by one.
The time complexity of the shift method is O(1) since it performs a constant number of operations regardless of the size of the linked list.
It directly accesses and updates the head node.

`get` method

The get method returns the node at the specified index in the linked list.

def get(index)
  return if index >= @length || index.negative?

  temp = @head
  (0...index).each do |_i|
    temp = temp.next
  end
  temp
end

The method first checks if the provided index is valid (within the range of the list).
If the index is not valid (greater than or equal to the length or negative), it returns nil.
Otherwise, it iterates through the list to reach the desired index and returns the corresponding node.
The time complexity of the get method is O(n), where n is the length of the linked list.
It needs to traverse the list to reach the desired index.

`set_value` method

The set_value method sets the value of the node at the specified index in the linked list.

def set_value(index, value)
  temp = get(index)

  if temp
    temp.value = value
    true
  else
    false
  end
end

The method first uses the get method to retrieve the node at the specified index.
If the node exists, it updates its value with the provided value and returns true.
Otherwise, it returns false.
The time complexity of the set_value method is O(n), where n is the length of the linked list.
It utilizes the get method, which has a time complexity of O(n), to retrieve the node at the specified index.

`insert` method

The insert method inserts a new node with the given value at the specified index in the linked list.

def insert(index, value)
  return if index >= @length || index.negative?

  return prepend(value) if index.zero?

  return append(value) if index == @length - 1

  temp = get(index - 1)

  new_node = Node.new(value)

  new_node.next = temp.next

  temp.next = new_node
  @length += 1
  true
end

First, it checks if the provided index is valid. If not, it returns nil.
If the index is zero, it uses the prepend method to add the new node at the beginning.
If the index is equal to the length minus one, it uses the append method to add the new node at the end.
Otherwise, it retrieves the node at the previous index (index - 1) using the get method.
Then, it creates a new node with the provided value and inserts it into the list by updating the next references accordingly.
At last, we increment length by one
The time complexity of the insert method is O(n), where n is the length of the linked list.
It utilizes the get method, which has a time complexity of O(n), to retrieve the node at the specified index.

`remove` method

The remove method removes and returns the node at the specified index in the linked list.

def remove(index)
  return if index >= @length || index.negative?

  return shift if index.zero?

  return pop if index == @length - 1

  prev = get(index - 1)
  temp = prev.next
  prev.next = temp.next
  temp.next = nil
  @length -= 1

  temp
end

The method first checks if the provided index is valid. If not, it returns nil.
If the index is zero, it uses the shift method to remove and return the head node.
If the index is equal to the length minus one, it uses the pop method to remove and return the tail node.
Otherwise, it retrieves the node at the previous index (index - 1) using the get method.
It updates the next references to detach the node at the specified index from the list.
At last, we decrement length by one.
The time complexity of the remove method is O(n), where n is the length of the linked list.
It utilizes the get method, which has a time complexity of O(n), to retrieve the node at the specified index.

`reverse` Method

The reverse method reverses the linked list by changing the order of the nodes.

def reverse
  temp = @head
  @head = @tail
  @tail = temp
  after = temp.next
  before = nil

  (0...@length).each do |_i|
    after = temp.next
    temp.next = before
    before = temp
    temp = after
  end
end

The method starts by swapping the head and tail nodes.
Then, it iterates through the list and reverses the next references of each node.
It uses three variables (temp, before, and after) to keep track of the nodes being reversed.
The loop continues until all nodes are reversed.
The time complexity of the reverse method is O(n), where n is the length of the linked list.
It needs to traverse the list once to reverse the nodes.

Implement Leaflet on rails with stimulus

Ankit Pariyar — Sun, 07 May 2023 04:12:45 +0000

Set up basic rails app

we will use database PostgreSQL, esbuild to bundle the project's JavaScript, and TailwindCSS for its CSS. We'll also skip installing a test framework by passing the -T flag.



rails new leaflet_map -T -d postgresql --css=tailwind --javascript=esbuild
cd leaflet_map
rails db:create

Configure Tailwind: In application.tailwind.css replace the @tailwinddirectives with @import



@import "tailwindcss/base";
@import "tailwindcss/components";
@import "tailwindcss/utilities";

Create basic MVC

create Place model which will have longitude, latitude and name attributes



rails g model Place name:string longitude:float latitude:float
rails db:migrate

add simple validation for name, longitude and latitude on Place model



class Place < ApplicationRecord
  validates :name, presence: true
  validates :latitude, numericality: { greater_than_or_equal_to:  -90, less_than_or_equal_to:  90 }
  validates :longitude, numericality: { greater_than_or_equal_to: -180, less_than_or_equal_to: 180 }
end

update seed.rb file to create some data for places



Place.create(name: 'Place-1', longitude: -70.06, latitude: 39.35)
Place.create(name: 'Place-2', longitude: -55.30, latitude: 35.20)
Place.create(name: 'Place-3', longitude: -80.20, latitude: 25.20)
Place.create(name: 'Place-4', longitude: -90.20, latitude: 15.20)

Run rails db:seed to seed data
Create PlacesController



rails g controller Places index

it will create PlacesController with index action as well as view files for index

Update PlacesController to show list of places



class PlacesController < ApplicationController
  def index
    @places = Place.all
  end
end

Also, update route.rb to make that index, home page



Rails.application.routes.draw do
  root 'places#index'
end

To test that every thing is working so far, run rails server withbin/rails and go to localhost
You can see default view provided by views/places/index.html.erb

Create basic map with leaflet

install leaflet



yarn add leaflet

update views/layouts/index.html.erb



<!DOCTYPE html>
<html>
  <head>
    <title>LeafletMap</title>
    <meta name="viewport" content="width=device-width,initial-scale=1">
    <%= csrf_meta_tags %>
    <%= csp_meta_tag %>

    <%= stylesheet_link_tag "application", "data-turbo-track": "reload" %>
    <%= javascript_include_tag "application", "data-turbo-track": "reload", defer: true %>
  </head>

  <body>
    <main class="container mx-auto mt-28 px-5">
      <%= yield %>
    </main>
  </body>
</html>

We just wrap main content that is <%= yield %> with <main class="container mx-auto mt-28 px-5"> just to give it a little bit style

Update views/places/index.html.erb this is place where we will display our map



<div class="w-full">
    <h1 class="font-bold text-4xl mb-2">Places</h1>
     <div data-controller="maps">
        <div data-maps-target="container" class="h-[75vh] w-auto"></div>
    </div>
</div>

The main things you need to focus here is data-controller="map" indicates stimulus controller and data-map-target="container" this allow us to define containerTarget on our map stimulus controller

Generate map stimulus controller



rails g stimulus map

update map_controller.js



import { Controller } from "@hotwired/stimulus"
import L from "leaflet"

export default class extends Controller {
  static targets = ["container"]

  connect() {
    this.createMap()
    this.map.setView([27.700769, 85.300140], 12);
  }

  createMap() {
    this.map = L.map(this.containerTarget)

    L.tileLayer('https://tile.openstreetmap.org/{z}/{x}/{y}.png', {
      maxZoom: 19,
      attribution: '&copy; <a href="http://www.openstreetmap.org/copyright">OpenStreetMap</a>'
    }).addTo(this.map);
  }

 disconnect() {
    this.map.remove();
  }
}

Here, first we import L from leaflet.when our element with attribute data-controller = "map" enters DOM connect will be called in which we use createMap function to create map.

With line static targets = ["container"] we add container target which we defined in our HTML with data-map-target="container" now that element can be access with this.containerTarget

Inside of createMap() function with line this.map = L.map(this.containerTarget) we initialize empty map inside containerTarget element and we added tile layer to our map with L.tileLayer

After creating map and adding tile, we set map's view to Kathmandu, Nepal with line this.map.setView([27.700769, 85.300140], 12)

Add <link rel="stylesheet" href="https://unpkg.com/leaflet@1.9.3/dist/leaflet.css" integrity="sha256-kLaT2GOSpHechhsozzB+flnD+zUyjE2LlfWPgU04xyI=" crossorigin=""/> inside head section of application.html.erb file for styling map



<!DOCTYPE html>
<html>
  <head>
    <title>LeafletMap</title>
    <meta name="viewport" content="width=device-width,initial-scale=1">
    <%= csrf_meta_tags %>
    <%= csp_meta_tag %>

    <%= stylesheet_link_tag "application", "data-turbo-track": "reload" %>
    <link rel="stylesheet" href="https://unpkg.com/leaflet@1.9.3/dist/leaflet.css"
     integrity="sha256-kLaT2GOSpHechhsozzB+flnD+zUyjE2LlfWPgU04xyI="
     crossorigin=""/>
    <%= javascript_include_tag "application", "data-turbo-track": "reload", defer: true %>
  </head>

  <body>
    <main class="container mx-auto mt-28 px-5">
      <%= yield %>
    </main>
  </body>
</html>

Now, restart rails server you can see map of Kathmandu,Nepal

Showing our list of places on map

Update index.html.erb



<div class="w-full">
    <h1 class="font-bold text-4xl mb-2">Places</h1>
     <div data-controller="map" data-map-latlong-value="<%=@places.pluck(:latitude, :longitude)%>">
        <div data-map-target="container" class="h-[75vh] w-auto"></div>
    </div>
</div>

Here, we add data-map-latlong-value="<%=@places.pluck(:latitude, :longitude)%>" which we can access with this.latlongValue from our map_controller.js

Update map_controller.js



import { Controller } from "@hotwired/stimulus"
import L from "leaflet"

export default class extends Controller {
  static targets = ["container"]
  static values = { latlong: Array }

  connect() {
    this.createMap()
    this.map.fitBounds(this.latlongValue)
    this.latlongValue.forEach(place => this.addMarker(place))
  }

  createMap() {
    this.map = L.map(this.containerTarget)

    L.tileLayer('https://tile.openstreetmap.org/{z}/{x}/{y}.png', {
      maxZoom: 20,
      attribution: '&copy; <a href="http://www.openstreetmap.org/copyright">OpenStreetMap</a>'
    }).addTo(this.map);
  }

  addMarker(place) {
    const [latitude, longitude] = place;
    L.marker([latitude, longitude])
      .addTo(this.map)
      .bindPopup(`<div>latitude: ${latitude}</div><div>longitude: ${longitude}</div>`)
  }


  disconnect() {
    this.map.remove();
  }
}

Line static values = { latlong: Array } add value latlong which datatype will be array and now we can access this value which we defined in index.html.erb with this.latlongValue

Instead of showing map of Kathmandu, Nepal with setView() function we use fitBounds() which take list of latitude and longitude and map will be adjusted to fit all of provided latitude and longitude

And for each latitude and longitude value we call function addMarker. Our addMarker function is responsible for adding marker to provided longitude and latitude and we also add popup showing it's latitude and longitude which will appear while clicking on marker with bindPopup

Now our map is look like this

Using Devise and SendGrid to send confirmation email on rails app

Ankit Pariyar — Sat, 18 Feb 2023 09:53:00 +0000

First make normal rails app with devise user model

$ rails new awesome-app This will create new app
$ cd awesome-app It will change the directory to our new project

Setup Gemfile

Add gem 'devise' and gem 'sendgrid-ruby' to the Gemfile
finally run $ bundle install on terminal

Setup devise

$ rails generate devise:install it will create config/initializers/devise.rb and config/locales/devise.en.yml file and follow the instruction generated by above command
Now generate devise user model with $ rails generate devise User

then go to app/models/user.rb and make this file look like this:

class User < ApplicationRecord
 # Include default devise modules. Others available are:
 # :confirmable, :lockable, :timeoutable, :trackable and :omniauthable
 devise :database_authenticatable, :registerable,
        :recoverable, :rememberable, :validatable, :confirmable

Uncomment the Confirmable section of migration file located on the app/db/migrate

class DeviseCreateUsers < ActiveRecord::Migration[7.0]
  def change
    create_table :users do |t|
      ## Database authenticatable
      t.string :email,              null: false, default: ""
      t.string :encrypted_password, null: false, default: ""

      ## Recoverable
      t.string   :reset_password_token
      t.datetime :reset_password_sent_at

      ## Rememberable
      t.datetime :remember_created_at

      ## Trackable
      # t.integer  :sign_in_count, default: 0, null: false
      # t.datetime :current_sign_in_at
      # t.datetime :last_sign_in_at
      # t.string   :current_sign_in_ip
      # t.string   :last_sign_in_ip

      # Confirmable
      t.string   :confirmation_token
      t.datetime :confirmed_at
      t.datetime :confirmation_sent_at
      t.string   :unconfirmed_email # Only if using reconfirmable

      ## Lockable
      # t.integer  :failed_attempts, default: 0, null: false # Only if lock strategy is :failed_attempts
      # t.string   :unlock_token # Only if unlock strategy is :email or :both
      # t.datetime :locked_at

      t.timestamps null: false
    end

    add_index :users, :email,                unique: true
    add_index :users, :reset_password_token, unique: true
    add_index :users, :confirmation_token,   unique: true
    # add_index :users, :unlock_token,         unique: true
  end
end

Then run $ rails db:migrate

Set up SendGrid

Create account on SendGrid
Set up a sender identity on SendGrid by clicking this link: https://app.sendgrid.com/settings/sender_auth/senders
Create your API key by following this link: https://app.sendgrid.com/settings/api_keys
add gem 'dotenv-rails' on development and test group on gem file and run $ bundle install
create .env file in your project root and add following line inside it SENDGRID_API_KEY = 'YOUR API KEY'
Then, modify this Devise config to use your SendGrid sender identity:

# config/initializers/devise.rb
config.mailer_sender = 'please-change-me-at-config-initializers-devise@example.com'

Set up Action Mailer

create config/initializers/action_mailer.rb file and add following code

 # config/initializers/action_mailer.rb
ActionMailer::Base.smtp_settings = {
    user_name: "apikey",
    password: ENV['SENDGRID_API_KEY'],
    domain: "your-domain.com",
    address: "smtp.sendgrid.net",
    port: 587,
    authentication: :plain,
    enable_starttls_auto: true
}

Now let Test it

run the server on local $ rails server
go to link http://localhost:3000/users/sign_up on browser

After signing up we will get the confirmation email.

Introduction to Blocks, Procs & Lambdas in Ruby

Ankit Pariyar — Fri, 17 Feb 2023 11:24:27 +0000

Block

Blocks are a set of instructions that can be passed to a method for execution. They are enclosed in a do-end block or between curly braces {}. Blocks can take multiple arguments, and their argument names are defined between two pipe characters ||.

Here's an example of a block that we can pass to the each method:

[1, 2, 3].each { |num| puts num }

In the above code, |num| is the argument of the block, and puts num is the instruction that will be executed on each element of the array.

Yield

Yield is a Ruby keyword that executes a block of code passed to a method. The code inside the block will run when you use the yield keyword.
Here's an example of a method that takes a block and uses the yield keyword to execute it:

def print_hello
  yield
end

print_hello { puts "Hello" }

In this example, the yield statement will execute the code inside the block and print "Hello" to the console.

You can also pass arguments to yield:

def one_two_three
  yield 1
  yield 2
  yield 3
end

one_two_three { |number| puts number * 2 }
# 2, 4, 6

Here, we are passing the numbers 1, 2, and 3 to the block and printing their multiples of 2 to the console.

Implicit vs Explicit Blocks

There are two ways to define a block in Ruby: implicit and explicit. An implicit block is not given a name in the parameter list. It is called using the yield keyword. On the other hand, an explicit block is given a name in the parameter list.
Here's an example of an explicit block:

def explicit_block(&block)
  block.call # same as yield
end

explicit_block { puts "Explicit block called" }

In the above example, the &block parameter is used to define the block's name. This allows us to pass the block to another method or save it into a variable to use later.

If you try to yield without a block, you will get a no block given (yield) error. To check if a block has been passed in, you can use the block_given? method.

Lambda

A lambda is a way to define a block and its parameters using a special syntax. A lambda can take arguments, and it won't run the code inside it until you call it using the call method.

Here's an example of a lambda:

hello_world = -> { puts "Hello world" }
hello_world.call

# "Hello World"

Lambdas can also take arguments, just like methods:

times_two = ->(x) { x * 2 }
times_two.call(10)
# 20

If you pass the wrong number of arguments to a lambda, it will raise an exception, just like a regular method.

Lambdas vs Procs

Procs are a very similar concept to lambdas, but with a few key differences. One of the differences is how you create them:

my_proc = Proc.new { |x| puts x }

A proc behaves differently than a lambda, especially when it comes to arguments. A proc will not raise an exception if you pass the wrong number of arguments to it:

my_proc.call(1, 2, 3) # prints 1

In this example, the proc only takes one argument, but we passed in three. The extra arguments are ignored.

Another difference between procs and lambdas is how they react to a return statement. A lambda will return normally, like a regular method. But a proc will try to return from the current context:

def test_proc
  my_proc = Proc.new { return "returning from proc" }
  my_proc.call
  return "returning from method"
end

def test_lambda
  my_lambda = -> { return "returning from lambda" }
  my_lambda.call
  return "returning from method"
end

puts test_proc # prints "returning from proc"
puts test_lambda # prints "returning from method"

In this example, the test_proc method returns from the proc instead of continuing to execute the method. The test_lambdamethod, on the other hand, returns normally because the lambda behaves like a regular method.

Advent of Code 2022 with Ruby day 01

Ankit Pariyar — Sat, 03 Dec 2022 12:54:20 +0000

Problem

We have text file which look like this

Above number represents Calories of the food carried by 3 Elves. Blank line separate the food carried by each Elves
We have to find total Calories of the food carried by Elf carrying the most Calories

Solution

First let's break down problem

Reading text file
Find out total calories carried by each Elves
Find out maximum out of that calories

calories_carried_by_each_elves = 0
max_calories = 0

File.foreach('day_01.txt') do |calories|
  if calories.to_i.positive?
    calories_carried_by_each_elves += calories.to_i
  else
    max_calories = calories_carried_by_each_elves if calories_carried_by_each_elves > max_calories
    calories_carried_by_each_elves = 0
  end
end

puts max_calories

Forem: Ankit Pariyar

Conditional CSS Classes in Rails with class_names

Set up RSpec, Shoulda matchers and FactoryBot on Rails 7

Rspec

Shoulda Matchers

FactoryBot

Doubly Linked List Implementation in Ruby

Table of Contents

Understanding Doubly Linked List

Implementation of Doubly Linked List

print_list method

append method

pop method

Prepend Method

Shift Method

Get Method

set_value Method

Insert Method

Remove Method

Reverse method

Introduction to Time Complexity with ruby

Table of Contents

Some terms

Time complexity

Space complexity

Worst/Best/Average

Rules for calculating Big O

O(n)

O(n^2)

O(log n)

When we have to loop through two inputs

Linked List with Ruby

Table of Contents

Understanding Linked Lists

Implementing a Linked List in Ruby

print_list method

append Method

pop Method

prepend Method

shift Method

get method

set_value method

insert method

remove method

reverse Method

Implement Leaflet on rails with stimulus

Set up basic rails app

Create basic MVC

Create basic map with leaflet

Showing our list of places on map

Using Devise and SendGrid to send confirmation email on rails app

First make normal rails app with devise user model

Setup Gemfile

Setup devise

Set up SendGrid

Set up Action Mailer

Now let Test it

Introduction to Blocks, Procs & Lambdas in Ruby

Block

Yield

Implicit vs Explicit Blocks

Lambda

Lambdas vs Procs

Advent of Code 2022 with Ruby day 01

Problem

Solution

`print_list` method

`append` method

`pop` method

`Prepend` Method

`Shift Method`

`Get` Method

`set_value` Method

`Insert` Method

`Remove` Method

`Reverse` method

`print_list` method

`append` Method

`pop` Method

`prepend` Method

`shift` Method

`get` method

`set_value` method

`insert` method

`remove` method

`reverse` Method