New JavaScript frameworks have emerged as a big programming language for both client and server side constantly, completely changing the way companies like Matrix Marketers think about building web applications. With the use of libraries, the server is no longer responsible for generating complete pages. Its role is often reduced to serving as a backend for the client-side Application. This approach has many advantages. To name a few:

The separation between presentation and business logic-  Instead of reloading the whole page, only parts that need to change are replaced.

Reduced Resources Usage – The partial access of data in form of small chunks reduces the risk of data stealing as well as pulling large parts of business logic into the web browser. This will reduce the work to be done by a server which can result in less use of the server that means cheaper applications. A good, well-defined API can be reused for all purposes.

The small changes in the configuration of useful gems, we can disable the parts of code which is not required. This is the main reason to use APIs in RoR development.

Routing – Rails routes are a great help in making RESTful APIs working. This is a great advantage to the APIs architecture

Rich library of third-party plugins – no matter what functionality your application needs, chances are that someone already implemented it convenient defaults for development mode logging and much more.

In this post, Matrix Marketers RoR developers, reveal methods of creating an API using Ruby on Rails. The developers have tried to cover some of the most common issues one can encounter when developing such application.

Getting Started

When creating an API application, Matrix Marketers RoR developers don’t need all the features that Rails provide out of the box. The first step is to add an appropriate entry to our Gem file. Next, we want our controllers to inherit from ActionController::  API.

To start building applications from scratch, you can install Rails-API as a standalone gem and generate the new project using   Rails:: API includes the sensible set of middlewares enabled by default. It’s possible to add the ones that are inactive. For example, to add Session Management, you simply need to add the following line in config:

Versioning

For a successful RoR application, API must remain stable and consistent. The route changing parameters may have any value of API or response format.The above statement is especially true for publicly available APIs, which can be used by a large number of third-party clients. On the other hand, an evolution of software is completely natural and inevitable. How can we reconcile these contradictions? API versioning to the rescue! Thanks to versioning, you can release new, improved API, without cutting off clients using the old one.  Create controllers structure analogous to the existing one.

Rendering Response

There are many formats, in which communication with the API can be performed. The most popular choices are XML and JSON. For our sample application, we will use the latter exclusively. JSON, or JavaScript Object Notation, has its origins in JavaScript but is widely supported by other programming languages, including Ruby. JSON’s is better to be used as compared with XML having simple syntax.

This way works perfectly fine for simple responses. However, if there’s more data you would like to return, you controller might get pretty fat. For these cases, we can use one of available DSLs.

Any lines starting with larger indentation than the current margin are treated as verbatim text. It’s great for embedding code snippets with syntax highlighting inside the documentation.

It’s also possible to use different markup format, then the default RDoc::Markup. RDoc has built in support for markdown, rd, and to the doc.

Handled at the middleware layer:

Reloading: Rails applications support transparent reloading. The feature is useful even when your application becomes big and restarting the server for every request becomes non-viable.

Development Mode: Rails applications come with smart defaults for development, making development pleasant without compromising production-time performance.

Logging: Every request is entered in a log in Rails application with a level of verbosity appropriate for the current mode. Rails logs in development have information about the request environment, database queries, and basic performance information.

Security:  IP spoofing attacks can be detected by rails application and handles cryptographic signatures in a timing attack.

Parameter Parsing: Rails application will decode the JSON and make it available in params. The use of nested URL-encoded parameter scan also is done.

Conditional GETs: Conditional GET processing can be done. You must check the controller and Rails will handle all of the HTTP details in the RoR application

HEAD requests: Rails will transparently convert HEAD requests into Getting ones, and return just the headers on the way out. This makes HEAD work reliably in all Rails APIs.

Conclusion

Matrix Marketers developers in this post have discussed basic steps required to build your own REST API with Ruby on Rails. It was by no means a detailed representation, but it should be enough to get you started on your way to mastering the art of building great APIs. Matrix Marketers strongly support the use of RESTful APIs in Ruby on Rails application to take the web applications on the next level of advancement.