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

Building the controller DSL

To successfully call the use Goldcrest.Controller statement, we will need to define a __using__/1 macro in Goldcrest.Controller, which is responsible for injecting a controller-like behavior into a module.

Let’s start by simply moving the Plug.Builder call, the Plug.Conn call, and the call/2 function to the Goldcrest.Controller.__using__/1 macro:

defmodule Goldcrest.Controller do
  import Plug.Conn
  defmacro __using__(_) do
    quote do
      use Plug.Builder
      import Plug.Conn
      def call(conn, action: action) do
        conn = super(conn, [])
        apply(__MODULE__, action, [conn, conn.params])
      end
    end
  end
  # ..
end

In the previous code snippet...

Previous Section
End of Section 5
Next Section