Book Image

Build Your Own Web Framework in Elixir

By : Aditya Iyengar
Book Image

Build Your Own Web Framework in Elixir

By: Aditya Iyengar

Overview of this book

Elixir's functional nature and metaprogramming capabilities make it an ideal language for building web frameworks, with Phoenix being the most ubiquitous framework in the Elixir ecosystem and a popular choice for companies seeking scalable web-based products. With an ever-increasing demand for Elixir engineers, developers can accelerate their careers by learning Elixir and the Phoenix web framework. With Build Your Own Web Framework in Elixir, you’ll start by exploring the fundamental concepts of web development using Elixir. You'll learn how to build a robust web server and create a router to direct incoming requests to the correct controller. Then, you'll learn to dispatch requests to controllers to respond with clean, semantic HTML, and explore the power of Domain-Specific Languages (DSL) and metaprogramming in Elixir. You'll develop a deep understanding of Elixir's unique syntax and semantics, allowing you to optimize your code for performance and maintainability. Finally, you'll discover how to effectively test each component of your application for accuracy and performance. By the end of this book, you'll have a thorough understanding of how Elixir components are implemented within Phoenix, and how to leverage its powerful features to build robust web applications.

Related Content you might be interested in

Current Title:

Small book image
Build Your Own Web Framework in Elixir
Aditya Iyengar
Jun, 2023 | 274 pages
Small book image
Mastering Elixir
Andr Albuquerque | Daniel Caixinha
Jul, 2018 | 574 pages
Small book image
Phoenix Web Development
Brandon Richey
Apr, 2018 | 406 pages
Table of Contents (15 chapters)
Preface
Preface
Who this book is for
What this book covers
To get the most out of this book
Download the example code files
Download the color images
Conventions used
Get in touch
Share Your Thoughts
Download a free PDF copy of this book
1
Part 1: Web Server Fundamentals
Part 1: Web Server Fundamentals
Free Chapter
2
Chapter 1: Introducing the Cowboy Web Server
Chapter 1: Introducing the Cowboy Web Server
Technical requirements
What is a web server?
Exploring the client-server architecture
Understanding HTTP
Understanding Cowboy’s architecture
Building a web application using Cowboy
Supervising the web server
Adding routes with bindings
Validating HTTP methods
Responding with HTML files
Testing the web server with ExUnit
Summary
Exercises
3
Chapter 2: Building an HTTP Server in Elixir
Chapter 2: Building an HTTP Server in Elixir
Technical requirements
Listening over a TCP socket using :gen_tcp
Responding over a TCP socket using :gen_tcp
Writing an HTTP server package
Defining an HTTP response struct
Validating whether a responder is configured
Creating responder behavior
Testing the HTTP server
Running the HTTP server with a sample application
Adding concurrency to the server
Bonus – starting a detached HTTP server
Summary
Exercise
4
Part 2: Router, Controller, and View
Part 2: Router, Controller, and View
5
Chapter 3: Defining Web Application Specifications Using Plug
Chapter 3: Defining Web Application Specifications Using Plug
Technical requirements
What is Plug?
Representing the state of the connection with the Plug.Conn struct
Defining a plug
Understanding Plug.Router
Plugifying our HTTP server
Summary
6
Chapter 4: Working with Controllers
Chapter 4: Working with Controllers
Technical requirements
What are controllers?
Controllers in Phoenix
Building a controller interface
Integration with web servers
Understanding redirects
Testing the controller
Summary
Exercises
7
Chapter 5: Adding Controller Plugs and Action Fallback
Chapter 5: Adding Controller Plugs and Action Fallback
Technical requirements
Plug pipeline in controllers
Understanding the Plug.Builder module
Building the controller pipeline
Implementing action fallback
Summary
8
Chapter 6: Working with HTML and Embedded Elixir
Chapter 6: Working with HTML and Embedded Elixir
Technical requirements
Understanding and exploring embedded elixir
Responding with html.eex files
Testing our templates
Testing with Floki
Summary
9
Chapter 7: Working with Views
Chapter 7: Working with Views
Technical requirements
What is a view?
Views in Phoenix
Building a view interface
Passing helper functions to templates
Taking Goldcrest for a spin
Summary
Exercises
10
Part 3: DSL Design
Part 3: DSL Design
11
Chapter 8: Metaprogramming – Code That Writes Code
Chapter 8: Metaprogramming – Code That Writes Code
Technical requirements
The pros and cons of metaprogramming
When to use metaprogramming
Metaprogramming in Elixir
Understanding quoted literals
Evaluating quoted literals
The hygienic evaluation of quotes
Adding dynamic behavior to quotes
Code injection using evaluation
Code injection using macros
The using macro
Compile-time callbacks
Building a music DSL in Elixir
Writing the implementation
Building the interface layer
Testing the interface
Adding DSL test helpers
Summary
Exercises
12
Chapter 9: Controller and View DSL
Chapter 9: Controller and View DSL
Technical requirements
Why use metaprogramming here?
DSL design
Building the controller DSL
Extracting response helpers
Building the View DSL
Building a web app using the DSLs
Creating test helpers for ease of testing and debugging
Summary
Exercises
13
Chapter 10: Building the Router DSL
Chapter 10: Building the Router DSL
Technical requirements
Why use metaprogramming here?
DSL design
Building the router DSL
Building router helpers
Creating test helpers
Summary
Exercises
14
Index
Index
Why subscribe?
Packt is searching for authors like you
Download a free PDF copy of this book

Understanding the Plug.Builder module

To add a similar plug pipeline to our controller, we will need to keep track of all the plug/3 calls in the controller and apply those plugs in the correct order whenever the controller receives a request. This sounds like a lot of work to do from scratch, but fortunately, the Plug package provides a module that could help – the Plug.Builder module.

The Plug.Builder module can be used to define a pipeline of plugs that are executed one after the other. It defines a plug/2 macro, which is the main interface to build a pipeline by adding a plug to the list of already registered plugs. The plugs in the pipeline are executed in the order of their definition, and the connection returned by the final plug is then passed along to the main plug call.

Here’s an example of this:

defmodule ExamplePlugPipeline do
  use Plug.Builder
  plug :plug1
  plug :plug2
  def plug1(conn, _opts) do
 ...
Previous Section
End of Section 4
Next Section