DEV Community: Magesh

Meta programming with Ruby Eval: A guide (Part 1)

Magesh — Mon, 06 Jan 2025 05:00:00 +0000

During one of our bootcamp study sessions, we explored Ruby's eval and discovered how powerful meta-programming in Ruby can be. It enables you to do almost anything at runtime, from evaluating complex expressions to creating classes, modules, methods, variables, and constants dynamically.

For starters, what is meta programming?
In simple terms, meta programming is about writing code that can generate more code.

Let me clarify, you write a code that generates more code during runtime which can then be executed dynamically.

It is not just about executing a logic like 2+2 or (a + b)²
Or calling a method dynamically like
send(:my_method)

In ruby, you can write code that will create classes, modules and methods, variables dynamically. It can even extend existing classes/modules and do more.

Basic Eval

When I was new to ruby, the only thing I knew about eval was to use it for evaluating simple expressions. I thought that was it; I didn't know it could do more.

You can use eval to execute arbitrary ruby code contained in a string like below:

eval("2+ 3+5")

While powerful, eval should be used cautiously as it executes code in the current binding and can pose security risks if used with untrusted input.

That was super simple but you can do much more. Let's explore more.

Instance Evaluation

instance_eval allows you to evaluate code in the context of an object's instance. This method is particularly useful when you need to:

Access instance variables directly
Define singleton methods on specific instances
Modify a single object's behaviour

Dynamically set or get instance variables

Let's define a class with an instance variable

class Person
  def initialize(name)
    @name = name
  end
end

person = Person.new("Magesh")

Use eval to dynamically set the instance variable like this:

eval "person.instance_variable_set(:@name, 'Dinesh')"
puts person.instance_variable_get(:@name) # Output: Dinesh

Use eval to dynamically get the instance variable like this:

eval_name = eval "person.instance_variable_get(:@name)"
puts eval_name # Output: Dinesh

Using `class_eval` to create class

Let's create a method that can create more classes by taking a name as an argument.

def create_dynamic_class(name, methods_to_add)
  Object.class_eval <<-RUBY
    class #{name}
      attr_reader :created_at
      def initialize(name)
     @name = name
        @created_at = Time.now
      end

    def greet
      "Hello! Welcome"
    end

    #adding a class method
      def self.description
        "I am a dynamically created class named #{name}"
      end
    end
  RUBY
end

Now whenever I want to create a class I can simply call the method like this:

create_dynamic_class('Dog', {})

# Let's execute the method and check
milo = Dog.new("Milo")
Dog.description # => I am a dynamically created class named Dog

That was simple, right? Now, how do we add instant methods to that class?
We have to tweak the code a little bit like adding a few more lines to the create_dynamic_class method.

# Add instance methods using class_eval with a block
  klass = Object.const_get(name)
  # Add each method to the class
  methods_to_add.each do |method_name, method_body|
    klass.class_eval do
      define_method(method_name, method_body)
    end
  end

The above code will take a hash with method names as keys and procs or blocks as values with the implementation.

We have to create a hash now to add some methods, let's see how its done

This is the hash:

my_methods = {
  greet: -> { "Ruf! Ruf!" },
  say_bye: -> { "Woof! Woof!" },
  birth_time: -> { "Born at: #{@created_at}" }
}

Now I have to call

create_dynamic_class("Dog", my_methods)

We can test it to check if all the methods are working:

milo = Dog.new("Milo")
milo.greet
milo.say_bye
milo.birth_time

that should give you the following output:

#<Dog:0x0000000110a16650 @created_at=2024-12-30 14:20:08.776167 -0500, @name="Milo">
"Ruf! Ruf!"
"Woof! Woof!"
"Born at: 2024-12-30 14:22:43 -0500"

See what we did? We have created a class dynamically and added a few instances and class methods to it. All during runtime. That was cool, right? Let's try one more thing.

Define singleton methods on specific instances

What if we only want to add methods to a specific instance of a class and not to all the instances(objects). In our code above we created a dog named Milo but what if there is another dog and it could do different things that Milo didn't?

simba = Dog.new("Simba")

Now, what if Simba could roll which Milo couldn't?

simba.instance_eval do
  def roll
    "#{@name} is rolling over!"
  end
end

Now, the above method roll will only be available inside the instance simba.

simba.roll  #=>  "Simba is rolling over!"

milo.roll   #=> undefined method `roll' for an instance of Dog (NoMethodError)

You see, if I call "roll" method on the instance "milo". I would get an undefined method error because we added the roll method only on the instance "simba". That's how you create a singleton method for an instance.

Great. That's enough for now. I'll show you more in Part 2.

Go to part 2 to read more

Meta programming with Ruby Eval: A guide (Part 2)

Magesh — Mon, 06 Jan 2025 05:00:00 +0000

Hope you read Part 1 of meta-programming with Ruby eval before coming here, if not you can click this link and read it first. It's kind of like a pre-requisite.

Meta programming with Ruby Eval - Part 1

In part one, we saw the basics of eval and how to dynamically create a class and add methods to it. Now let's see how we can extend a class, and also learn how to create modules and use them in classes, during runtime. Ready? Let's dive right in.

Extending a class

Let's say we already have a class file, we can extend it dynamically during runtime to add more instance and class methods.

Consider the below example Animal class:

class Animal
  def initialize(name)
    @name = name
  end
end

To add more methods to it, we can simply use the following:

## Adding methods using class_eval
Animal.class_eval do
  def speak
    "#{@name} makes a sound"
  end

  def self.species
    @species ||= []
  end

  # Add attribute readers dynamically
  attr_reader :name
end

The above code adds an instance method called "speak", a class method "species", and also an attribute reader to read the @name value.

Overriding methods in class or redefining existing behaviour

Now, let's assume the Animal class had a method called "name", like so:

class Animal
  def initialize(name)
    @name = name
  end

  def name
    print "The name is #{@name}"
  end
end

I can override it on the fly using the following code:

Animal.class_eval do
  # Store the original method
  alias_method :original_name, :name

  def name
    puts "You can call me #{@name}!"
  end
end

I can use the class_eval to override any method in any class during runtime. But we have to be careful not to change an expected behaviour which might lead to misunderstanding and cause trouble for other developers.

Dynamically create Attribute methods

You want to write attribute methods: reader and writer, here's how

['age', 'color', 'breed'].each do |attribute|
  Animal.class_eval do
    # Create getter
    define_method(attribute) do
      instance_variable_get("@#{attribute}")
    end

    # Create setter
    define_method("#{attribute}=") do |value|
      instance_variable_set("@#{attribute}", value)
    end
  end
end

# Usage examples
dog = Animal.new("Rex")
puts dog.speak              # => "Loudly: Rex makes a sound"

dog.age = 5
dog.color = "brown"
puts "#{dog.name} is #{dog.age} years old and #{dog.color}"

Create Modules using `class_eval`

In part one we saw how to create classes, similarly, can I create modules? and maybe include them in classes? Yes, we can. The following code does that:

# Creating a module 
module_code = <<-RUBY
  module Swimmable
    def swim
      "\#{@name} is swimming!"
    end
  end
RUBY

Now that's the module code but I need to evaluate it first and then include it in a class to make it work, right? So how can we do that?

# Evaluate the module code and include it
Object.class_eval(module_code)
Animal.class_eval { include Swimmable }

In the above code, I first evaluate the module code using Object.class_eval and then to include it in a class we used class_eval on the class itself. That's it. Now I can check it by using the following code:

animal = Animal.new("panda")
puts animal.swim

That should work. Now you know how to create modules on the fly and include them in any existing class or we can also create a class on the fly and include the module in it.

Adding methods to a module

Let's create a real-world use case. A validation DSL:

module Validators
  def self.create_validator(field, &validation_logic)
    module_eval do
      define_method("validate_#{field}") do |value|
        if validation_logic
          instance_exec(value, &validation_logic)
        else
          value.nil? ? false : true
        end
      end
    end
  end
end

You can use the Validators module to create basic presence validation like the following:

class User
  include Validators

  attr_accessor :email, :age, :username

  # Create basic presence validators
  create_validator :email
  create_validator :age
  create_validator :username
end

user = User.new
puts user.validate_email(nil)      # => false
puts user.validate_email("test@example.com")  # => true

If you want to create a custom validation to check the price value, etc. You can do something like this:

create_validator(:price) { |value| value.to_f > 0 }

See how helpful this can be?

Extending Modules

module Extensions
  module_eval do
    def self.included(base)
      base.extend(ClassMethods)
    end

    module ClassMethods
      def class_method
        puts "This is a class method"
      end
    end
  end
end

Class and Module Evaluation

module_eval (also aliased as module_exec) is a method that allows you to evaluate code in the context of a module. Like class_eval, it lets you define or modify methods that will be instance methods of classes that include the module.

module Greeting
  def self.add_greeting(name)
    module_eval(<<-RUBY)
      def greet_#{name}
        puts "Hello, #{name}!"
      end
    RUBY
  end
end

class Person
  include Greeting
end

Greeting.add_greeting("alice")
person = Person.new
person.greet_alice  # Output: Hello, alice!

While module_eval and class_eval are very similar, there are some key differences:

Context: module_eval is specifically for modules, while class_eval is for classes. However, since classes are also modules in Ruby (Class inherits from Module), you can use module_eval on classes too.

# These are equivalent for classes
MyClass.class_eval do
  def some_method
    puts "Hello"
  end
end

MyClass.module_eval do
  def some_method
    puts "Hello"
  end
end

module_eval is often used in module methods to define methods dynamically that will be available to all classes including that module.

Dynamic Method Definition

define_method is a powerful way to create methods dynamically:

class APIWrapper
  ['get', 'post', 'put', 'delete'].each do |http_method|
    define_method(http_method) do |url, params = {}|
      # Generic HTTP request handling
      puts "Making #{http_method.upcase} request to #{url}"
    end
  end
end

api = APIWrapper.new
api.get('/users')   # => "Making GET request to /users"
api.post('/users')  # => "Making POST request to /users"

Removing Methods

Just as we can define methods dynamically, we can remove them:

class Example
  def temporary_method
    "I won't be here long"
  end

  remove_method :temporary_method
end

Dynamic Constant and Variable Management

Setting Constants

module Configuration
  const_set(:API_VERSION, "v1")
  const_set(:MAX_RETRIES, 3)
end

puts Configuration::API_VERSION  # => "v1"

Variable Operations

class StateManager
  class_variable_set(:@@state, {})

  def self.state
    class_variable_get(:@@state)
  end

  def update_state(key, value)
    instance_variable_set("@#{key}", value)
  end
end

Best Practices and Warnings

Security Considerations

Never use eval with untrusted input
Prefer more specific evaluation methods over basic eval
Use define_method instead of eval when defining methods dynamically

Performance Impact

Evaluation methods are slower than static definitions
Cache results when doing repeated evaluations
Consider using metaprogramming during class loading rather than runtime

Code Readability

Document why you're using metaprogramming
Keep dynamic code generation simple and obvious
Consider whether a more straightforward approach might work better

Ruby's evaluation methods provide powerful tools for metaprogramming, allowing you to write more dynamic and flexible code. While these tools should be used judiciously, understanding them opens up new possibilities for solving complex problems elegantly.

Remember that with great power comes great responsibility – always consider whether metaprogramming is the best solution for your specific use case, and document your code well when you do use it.

That's all for now. Thank you for reading it till the end.

The GOAT Ruby on Rails 8 is here - What's new?

Magesh — Sun, 05 Jan 2025 17:55:50 +0000

DHH and the team recently launched Rails 8 in style at the Rails World Conference, like never before. Why? because this new version comes with a lot of features that are going to make it the God of all web frameworks

We love how it simplifies the whole web development process helping you go from MVP to IPO in less time than you can imagine. You do not need a PAAS or any fancy cloud infrastructure anymore, you can build and deploy your product in a few seconds. More power to open-source.

Isn't that fascinating? Let's look at how Rails 8 does that.

Unparalleled Performance

Rails 8 includes enhancements to how ActiveRecord handles database queries, aiming for faster execution and reduced overhead. It has faster boot times for applications. Native support for multithreading and asynchronous processing and reduced memory consumption.

Zero-Downtime Deployment Made Simple - Kamal 2

Kamal is an open-source zero-downtime deployment tool that simplifies server provisioning and running Rails applications on Docker containers. With Kamal, all you need is the IP address of your server or virtual machine (VM), and it handles everything—from installing development tools and dependencies to configuring your environment. It's that simple.

Rails 8 now comes preconfigured with Kamal 2 and a highly optimized Dockerfile. This combination can transform a brand-new Linux server or VM into a fully functional application server with a single command: kamal setup. Deployment has never been easier.

Kamal also provides super-fast zero-downtime deploys, automated SSL certificates via Let’s Encrypt, and support for multiple applications on a single server without any complicated configuration.

Apache or Nginx not required anymore

You no longer need Apache or Ngnix as a proxy server to work alongside your Rails Puma server. Introducing Thruster—a modern, lightweight proxy designed to sit in front of your Puma server.
Thruster efficiently handles incoming internet traffic while providing features such as asset caching, compression, etc.

Solid Cable - Redis is no longer required

You can now handle WebSocket functionality with just SQLite, eliminating the need for Redis or even a complex setup with MySQL or PostgreSQL. Solid Cable makes real-time messaging simple and accessible without relying on additional infrastructure.

Solid Cache - Memcache or Redis is no longer required

If you want to fragment cache HTML for your rails application, you can do so with ease without the dependencies required before like memcache or redis service. Add a few lines of config and you can enable caching for your application. Caching no longer uses RAM storage instead it uses the disk which is cheaper.

Solid Queue - Background job frameworks are not needed

Forget about integrating separate background job processing frameworks like Resque, Sidekiq, or Delayed Job. You can simply enable a solid queue in a few seconds which uses your existing database. Don't need Redis or any other dependencies for this purpose if you want to keep things simple.

Solid Queue can either run as a puma plugin, which is the default on a single-server installation, or by using the new bin/jobs command for starting a dedicated dispatcher.

It is running on Production and is scalable.

Solid Queue has been meticulously developed within the pressures of a real production environment over the last 18 months, and today it’s running 20 million jobs per day for HEY alone at 37signals.

No Build - Asset Management Simplified

Propshaft is the new tool that bids goodbye to more than a decade-old Sprockets. The Javascript ecosystem has come a long way. We are at a time when we don't have to put up with the whole npm install and node-modules complexity. Now that all the major browsers support ES6 as default we no longer need to transcompile or other outdated processes.

As the new asset pipeline, Propshaft only does 2 things now: Provide a load path for assets and stamp them with digests to allow for far-future expiry. Sprockets did a million other things that are no longer required if you want to keep things simple.

Generate your own authentication - Sorry, Devise!

Most of the time people worry about using 3rd parties or plugins for authentication. Now, you can have your own authentication generated with a simple command. You have full control and it can be customized however you want.

Just run bin/rails generate authentication and you’ll get basic models for Session and User, together with a PasswordsMailer, SessionsController, and an Authentication concern

Want to know more?

ActiveRecord Enhancements:

— Out-of-the-box support for JSONB queries, making it easier to handle structured data.
— Optimized eager loading for associations to reduce query overhead.
— Enhanced encryption for sensitive data, ensuring better security.

API improvements:

— Improved lightweight API-only mode for faster and more efficient APIs.
— Enhanced JSON serialization with optimized serializers for better performance.
— Native support for GraphQL, making it easier to build powerful APIs.

Security Enhancements:

— Automatic generation of Content Security Policies (CSP) for better protection against XSS attacks.
— Strengthened CSRF protection for AJAX requests.
— Default configuration for secure headers to improve application security.
— Advanced management of encrypted credentials, ensuring sensitive data is secure.

Developer Experience Enhancements:

— Improved error pages with actionable insights to debug issues faster.
— Enhanced logging with structured logs for better debugging and monitoring.
— A more interactive Rails console, improving developer productivity.
— Simplified scaffolding with updated default templates to get started quickly.

What are you waiting for? Try Rails 8 Today!

Rails on Rails 8 is packed with performance, security, and developer experience upgrades, making it the best choice for building modern applications. Whether you're starting a new project or considering upgrading your existing apps, Rails 8 is worth the move.

Need help migrating your older apps to the latest version of Ruby on Rails? Contact RailsFactory—we’re here to make your transition smooth and efficient. Let’s take your apps to the next level together!

Write a SQL query

Magesh — Tue, 16 Jul 2024 12:39:45 +0000

Find the Total_Salary(Salary + Incentives) received by each employee

Ruby is not dying — It’s Aging like fine wine

Magesh — Mon, 25 Mar 2024 07:58:15 +0000

A few years ago, I noticed the growing popularity of JavaScript and felt that sticking solely to Ruby might not be sufficient. I decided to deepen my knowledge by exploring JavaScript, Node, React, Next.js, etc. I worked on a few projects and taught a lot of people through workshops.

Fast forward to now, it’s been about five years, I haven’t written much Ruby code, and I’ve almost forgotten how simple it can be to write a piece of code. I’ve missed Ruby so much after seeing what the other side looks like, and now, I’m thinking of returning to the Ruby world (screw popularity and trends)

Meanwhile, people have been asking if Ruby/Rails is dead, so here’s the reality:

Ruby isn’t dead, it’s mature. And like a seasoned professional, maturity brings its own set of strengths and values. Rails continues to be the outstanding prototyping framework it was 20 years ago with the release of new features like Hotwire which lets you accomplish more on the front-end without writing any Javascript code. That’s Rails magic.

Ruby is not trending anymore but that doesn’t mean the language is about to die. If anything, it is aging like fine wine. Developers might jump ship based on changing trends but Ruby will live because of its powerful community and people like us who continue to use it.

Enough talk, Let’s look at some key data points from the Stack Overflow 2023 Developer Survey that showcase Ruby’s continued relevance and potential:

Popularity and Usage:

- Overall Usage:
While slightly down to 6.23% compared to 6.05% in 2022, Ruby holds the 16th position among the most used technologies (it’s above Dart, Scala, Swift, and Elixir in ranking). This indicates its continued presence in the developer landscape.

- Professional Usage:
Among professional developers, Ruby usage is 6.94% in 2023, compared to 6.72% in 2022, showing a slight upward trend. This suggests continued adoption and demand for Ruby skills in the professional job market.

- Learning:
2.55% of respondents are interested in learning Ruby, similar to the previous year (2.52%). This suggests a steady interest in the language, particularly among new developers even though it is low compared to other languages like Python and Javascript. Attracting new talent to the Ruby ecosystem might require some focused efforts.

Developer Satisfaction and Experience:

- Satisfaction:
47.69% of developers who use Ruby admire it, indicating a positive sentiment towards the language and its capabilities.

- Years of Experience:
Ruby developers have an average of nearly 12 years of experience, highlighting a mature and experienced user base. This often translates to greater skills and expertise within the community.

Other Interesting Points:

- Pay:
Interestingly, professional Ruby developers report a higher median salary than Python, Go, Scala, or Java developers (That is a surprise). According to the survey, the median salary for professional Ruby developers is $98,522 which has increased compared to the previous year ($93,000). This suggests that Ruby skills can be financially rewarding for experienced developers.

- Web Development Usage:
While Ruby on Rails, the popular web framework built on Ruby, saw a slight dip to 5.49% usage in 2023 from 5.83% in 2022, it still ranks among the top web frameworks. This indicates its continued relevance in web development, even if it is not experiencing explosive growth.

In conclusion, the Stack Overflow Developer Survey data paints a nuanced picture of Ruby. While it may not be the most popular language, it still holds relevance and value for developers, particularly those seeking a stable, mature, and rewarding career path.

Its strong community, rich ecosystem, and potential for higher compensation make it a language worth considering for both seasoned developers and those embarking on their development careers.

Maturity and stability: Ruby and Rails have been around for over 25 years, giving them a strong foundation and a proven stability and reliability track record. This can be attractive for projects requiring long-term maintenance and scalability.

Flexibility and adaptability: Ruby’s dynamic nature and extensive library of gems allow developers to build a wide range of applications without getting bogged down in complex frameworks or configurations.

Remember, while trends may shift, the value of a language often lies in its ability to solve problems effectively and efficiently. Ruby, with its unique strengths and dedicated community, continues to be a valuable tool in the developer’s toolbox.

There are always exciting developments in Ruby and Rails every once in a while. I’m eagerly waiting to see more interesting features and can’t wait to start my next project in Rails with Hotwire. I also want to explore Turbo Native and Strada. See? Many new things.

To sum it all up, the evening will feature a variety of cocktails, beers, and even tequila shots, but wine enthusiasts will remain steadfast. Do you catch my drift?

Ciao.