ruby-interview-seniour Cheat Sheet by artifactzone

Active Record is the M in MVC - the model - which is the layer of the system respon­sible for repres­enting business data and logic. Active Record facili­tates the creation and use of business objects whose data requires persistent storage to a database. It is an implem­ent­ation of the Active Record pattern which itself is a descri­ption of an Object Relational Mapping system.

In Active Record, objects carry both persistent data and behavior which operates on that data. Active Record takes the opinion that ensuring data access logic as part of the object will educate users of that object on how to write to and read from the database.

Active Record gives us several mechan­isms, the most important being the ability to:

Represent models and their data.
Represent associ­ations between these models.
Represent inheri­tance hierar­chies through related models.
Validate models before they get persisted to the database.
Perform database operations in an object­-or­iented fashion.

Object Relational Mapping, commonly referred to as its abbrev­iation ORM, is a technique that connects the rich objects of an applic­ation to tables in a relational database management system. Using ORM, the properties and relati­onships of the objects in an applic­ation can be easily stored and retrieved from a database without writing SQL statements directly and with less overall database access code.

If some code does work from the point of view of an Active­Record model, it can go into the model.

If some code does work that spans multiple tables­/ob­jects, and doesn’t really have a clear owner, it could go into a Service Object.

Anything that’s attrib­ute­-like (like attributes calculated from associ­ations or other attrib­utes) should go into your Active­Record model.

If you have logic that has to orches­trate the saving or updating of multiple models at once, it should go into an Active­Model Form Object.

If code is mostly meant for displaying or formatting models in a view, it should go into a Rails helper or a Presenter.

The asset pipeline provides a framework to concat­enate and minify or
compress JavaScript and CSS assets. It also adds the ability to write these assets
in other languages and pre-pr­oce­ssors such as Coffee­Script, Sass, and ERB

Rails provides a set of rake tasks to work with migrations which boil down to running certain sets of migrat­ions.

The very first migration related rake task you will use will probably be rake db:mig­rate. In its most basic form it just runs the up or change method for all the migrations that have not yet been run. If there are no such migrat­ions, it exits. It will run these migrations in order based on the date of the migration.

Note that running the db:migrate also invokes the db:sch­ema­:dump task, which will update your db/sch­ema.rb file to match the structure of your database.

Scoping allows you to specify common­ly-used queries(it can be considered as a shortcut for long or most frequently used queries) which can be referenced as method calls on the associ­ation objects or models. With these scopes, you can use every method previously covered such as where, joins and includes. All scope methods will return an Active­Rec­ord­::R­elation object which will allow for further methods (such as other scopes) to be called on it.

Rack is the underlying technology behind nearly all of the web frameworks in the Ruby world.
"­Rac­k" is actually a few different things:
An archit­ecture - Rack defines a very simple interface, and any code that conforms
to this interface can be used in a Rack applic­ation. This makes it very easy to build small,
focused, and reusable bits of code and then use Rack to compose these bits into a larger applic­ation.

A Ruby gem - Rack is is distri­buted as a Ruby gem that provides the glue code needed to compose our code.

require "­rac­k"
require "­thi­n"

class HelloWorld
def call(env)
[ 200, { "­Con­ten­t-T­ype­" => "­tex­t/p­lai­n" }, ["Hello World"] ]
end
end

Rack::­Han­dle­r::­Thi­n.run HelloW­orl­d.new
https:­//g­ith­ub.c­om­/su­nli­ght­lab­s/r­ack­-ho­neypot

Rack defines a very simple interface. Rack compliant code must have the following three charac­ter­istics:

It must respond to call
The call method must accept a single argument -
This argument is typically called env or enviro­nment, and it bundles all of the data about the request.
The call method must return an array of three elements These elements are, in order,
status for the HTTP status code, headers, and body for the actual content of the response.
A nice side effect of the call interface is that procs and lambdas can be used as Rack objects.

Middleware are the building blocks of larger applic­ations built using the Rack pattern.
Each middleware is a Rack compatible applic­ation, and our final applic­ation is built by composing together, or nesting these middle­ware.

Unlike base Rack apps, middleware must be classes as they need to have an initia­lizer which will be passed the next app in the chain.
For our first middleware example, we'll introduce a middleware that logs the amount of time the request took and adds that to the response.

To begin, we'll update our core Rack app to sleep for 3 seconds to give us something worth logging, and then we'll build our middle­ware:
Rack::­Han­dle­r::­Thi­n.run Loggin­gMi­ddl­ewa­re.n­ew­(app)

Middleware are perfect for non-app specific logic.
Things like setting caching headers, logging, parsing the request object, etc. all are great use cases for Rack middle­ware.
For example, in Rails, cookie parsing, sessions, and param parsing are all handled by Middle­ware.

The RubyGems software allows you to easily download, install, and use ruby software packages on your system.
The software package is called a “gem” which contains a packaged Ruby applic­ation or library.

Strong Parameters is a feature of Rails that prevents assigning request parameters to objects unless they have been explicitly permitted. It has its own DSL (Domain Specific Language, or in other words, a predefined syntax it unders­tands), that allows you to indicate what parameters should be allowed. It also lets you indicate if each parameter should be a hash, array or scalar (i.e. integer, string, etc.), as well as some other functi­onality

Send http requests to applic­ation and writing assertions about the response.

They are opposite ends of the rendering process, with yield specifying where content goes, and conten­t_for specifying what the actual content is.

The best practice is to use yield in your layouts, and conten­t_for in your views. There is a special second use for conten­t_for, where you give it no block and it returns the previously rendered content. This is primarily for use in helper methods where yield cannot work. Within your views, the best practice is to stick to yield :my_co­ntent to recall the content, and conten­t_for :my_co­ntent do...end to render the content.

HTTPS protects the commun­ication between your browser and server from being interc­epted and tampered with by attackers. This provides confid­ent­iality, integrity and authen­tic­ation to the vast majority of today's WWW traffic. Any website that shows a lock icon in the address bar is using HTTPS

In computer progra­mming, unit testing is a software testing method by which individual units of source code—sets of one or more computer program modules together with associated control data, usage proced­ures, and operating proced­ure­s—are tested to determine whether they are fit for use

Test actual result of execution, integr­ation tests, rather than only unit tests. Write scenario as a complex test