Hire our Elite Ruby on Rails Developers

Polymorphic associations enable a single model to be associated with multiple other models. For example, if you have two models, Employee and Product, and each one needs an image, without polymorphic associations, you would need two different models (EmployeePicture and ProductPicture) and two tables (employee_pictures and product_pictures). With polymorphic associations, you can use only one table to store the pictures since they can be linked to multiple models.

Inheritance allows the programmer to take on the attributes of one class into another. Ruby is limited to single class inheritance, but mixins are a feature that can be used to incorporate elements of multiple classes.

class Mammal

def breathe

puts "inhale and exhale"

end

end

class Cat < Mammal

def speak

puts "Meow"

end

end

cat = Cat.new

cat.breathe # => “inhale and exhale”

cat.speak # => “Meow”

Encapsulation keeps the internal details of an object hidden from the outside, allowing only the object to interact with its data. Public methods can be made available to provide a designated way to access the logic inside the object.

class Document

attr_accessor :name

def initialize(name)

@name = name

end

def set_name(name)

@name = name

end

end

d = Document.new('name1')

d.set_name('name1')

Polymorphism allows for a single interface to be used for different types of entities.

class Document

def initialize

end

def print

raise NotImplementedError, 'You must implement the print method'

end

end

class XmlDocument < Document

def print

p 'Print from XmlDocument'

end

end

class HtmlDocument < Document

def print

p 'Print from HtmlDocument'

end

end

XmDocument.new.print # Print from XmlDocument

HtmlDocument.new.print # Print from HtmlDocument

Although they appear alike, both can store function definitions or constants, there are still some distinctions between them:

You can create objects from a class, but not do from a module.

you can create subclasses from a class, but it is not possible to create submodules from a module

Modules are intended to be included on classes

Using "include ModuleName" allows the methods from the module to be accessed as instance methods of the class, while "extend ModuleName" adds the methods as class methods. If "include" is used, the instance can directly access the methods.

my = MyClass.new

my.method_defined_in_module

When using extends, the methods can be accessed directly from the class, for example:

MyClass.method_defined_in_module

ActiveSupport::Concern offers an easier means of designing modules that can be integrated into other classes, and resolves constant dependencies automatically. A common use for concerns is to separate out code fragments that can be reused in multiple models.

Procs are objects, allowing us to make objects from them and handle them like any other class instance. Lambdas are a type of Proc that verify its arguments, whereas procs do not. Both can be used to construct a block and store it in a variable to later give to a method. Blocks are like unnamed functions that can be given to methods, and are invoked when the yield keyword is used in a method definition.

A hash is implemented where the keys ":foo" and "foo" are seen as equivalent. In the writing interface (when using []=, merge, etc.), symbols are converted to strings internally.

Methods

respond_to_missing?: a way to make sure your dynamic methods defined with method_missing also handle respond_to? correctly

method_missing: called when a method cannot be found, potentially to allow dynamically defining one instead

method_added: called whenever a method is added… which can be used to modify the method

method_removed: called whenever a method is removed

singleton_method_added: method added to the singleton class of the object, to be callable just on this one instance

singleton_method_removed: method removed from singleton class

method_undefined: a method has been undefined, with undef_method. Undef_method is different from remove_method because remove_method may still allow superclasses to define the method – undef_method means it’s gone entirely.

singleton_method_undefined: called when a singleton method is undefined entirely

initialize_copy: an optional callback when cloning any Object

Classes

inherited: a Ruby class is subclassed

Modules

append_features: a Module is included, and its constants, methods and variables used

included: a Module is included, which usually obsoletes “append_features”

extend_object: a Module extends an Object

extended: an Object is extended by a module, which mostly obsoletes extend_object

const_missing: a constant isn’t already present

Rails utilizes its UJS library to detect clicks on links that have been given the data-remote=true attribute. This prevents the browser from performing its default action, and instead performs an AJAX request. The URL typically ends in .js; for example, /users.js.

Typically, the response from a remote request is a Javascript response, which means that the web browser will interpret the content of the response using Javascript. In Rails, the response is generated from a view partial with a .js.erb file extension, which allows Ruby code to be evaluated prior to the Javascript code being sent back to the browser.

The process of populating the database with test or default data is done with the Seeds file. If there are multiple Seeds files, they need to be manually added to the db/seeds.rb file

app/controllers/admin/managers_controller.rb

ActiveRecord is a user-friendly way to create SQL queries with Ruby and link the results from the database to ActiveRecord models if possible. This process is simplified as ActiveRecord translates the queries into SQL before sending them to the database. Although this is convenient and easy to learn, it can be limiting when it comes to intricate SQL queries. Arel, which is the library used internally by ActiveRecord to construct SQL queries, also lets users build SQL queries with Ruby, but it is more versatile. It provides a Ruby interface to enable dynamic composition of SQL queries, making it a stronger and more well-designed option.

Sequel, pretty powerful and flexible

This response is based on opinion, so consider the reasons behind it. For instance, Aaron Patterson is putting a lot of effort into achieving the Ruby 3x3 goal (version 3 will be three times faster).

This response is formed from the perspective. The official Rails Blog, the Slack Ruby Community, and the Ruby subreddit were consulted.