up tp Chapter 2 - Compile-time hooks

Author: shmink

README.md

@@ -16,20 +16,26 @@ Moreover, don't expect direct quotes, changing the sentences vocbulary helps me
 <details>
 <summary>Chapter 1 - The Language of Macros</summary>
 
--   [What are Macros?](chapters/chapter1.md/#what-are-macros)
--   [The Abstract Syntax Tree](#the-abstract-syntax-tree)
--   [Trying It All Together](#trying-it-all-together)
--   [Macro Rules](#macro-rules)
--   [The Abstract Syntax Tree - Demystified](#the-abstract-syntax-tree-demystified)
--   [High-Level Syntax vs. Low-level AST](#high-level-syntax-vs-low-level-ast)
--   [AST Literals](#ast-literals)
--   [Macros: The Building Blocks of Elixir](#macros-the-building-blocks-of-elixir)
--   [Macro Expansion](#macro-expansion)
--   [Code Injection and the Caller's Context](#code-injection-and-the-callers-context)
+-   [What are Macros?](chapters/chapter1.md#what-are-macros)
+-   [The Abstract Syntax Tree](chapters/chapter1.md#the-abstract-syntax-tree)
+-   [Trying It All Together](chapters/chapter1.md#trying-it-all-together)
+-   [Macro Rules](chapters/chapter1.md#macro-rules)
+-   [The Abstract Syntax Tree - Demystified](chapters/chapter1.md#the-abstract-syntax-tree-demystified)
+-   [High-Level Syntax vs. Low-level AST](chapters/chapter1.md#high-level-syntax-vs-low-level-ast)
+-   [AST Literals](chapters/chapter1.md#ast-literals)
+-   [Macros: The Building Blocks of Elixir](chapters/chapter1.md#macros-the-building-blocks-of-elixir)
+-   [Macro Expansion](chapters/chapter1.md#macro-expansion)
+-   [Code Injection and the Caller's Context](chapters/chapter1.md#code-injection-and-the-callers-context)
 
 </details>
 
 <details>
 <summary>Chapter 2 - Extending Elixir with Metaprogramming</summary>
-stuff
+
+-   [Re-Creating the if Macro](chapters/chapter2.md#re-creating-the-if-macro)
+-   [Adding a while Loop to Elixir](chapters/chapter2.md#adding-a-while-loop-to-elixir)
+-   [Smarter Testing with Macros](chapters/chapter2.md#smarter-testing-with-macros)
+-   [Extending Modules](chapters/chapter2.md#extending-modules)
+-   [Using Module Attributes for Code Generation](chapters/chapter2.md#using-module-attributes-for-code-generation)
+
 </details>

assertion/assert_step1.exs

@@ -0,0 +1,8 @@
+defmodule Assertion do
+  # {:==, [context: Elixir, import: Kernel], [5, 5]}
+  defmacro assert({operator, _, [lhs, rhs]}) do
+    quote bind_quoted: [operator: operator, lhs: lhs, rhs: rhs] do
+      Assertion.Test.assert(operator, lhs, rhs)
+    end
+  end
+end

assertion/assert_step2.exs

@@ -0,0 +1,35 @@
+defmodule Assertion do
+  defmacro assert({operator, _, [lhs, rhs]}) do
+    quote bind_quoted: [operator: operator, lhs: lhs, rhs: rhs] do
+      Assertion.Test.assert(operator, lhs, rhs)
+    end
+  end
+end
+
+defmodule Assertion.Test do
+  def pass do
+    [:green, :bright, "PASSED!"]
+    |> IO.ANSI.format()
+    |> IO.puts()
+  end
+
+  def fail(lhs, rhs) do
+    fail =
+      [:red, :bright, "FAILED:"]
+      |> IO.ANSI.format()
+
+    IO.puts("""
+    #{fail}
+    Expected:     #{lhs}
+    but received: #{rhs}
+    """)
+  end
+
+  def assert(operator, lhs, rhs) do
+    case operator do
+      :== -> if lhs == rhs, do: pass(), else: fail(lhs, rhs)
+      :> -> if lhs > rhs, do: pass(), else: fail(lhs, rhs)
+      :< -> if lhs < rhs, do: pass(), else: fail(lhs, rhs)
+    end
+  end
+end

assertion/math_test_import.exs

@@ -0,0 +1,11 @@
+defmodule MathTest do
+  import Assertion
+
+  def run do
+    assert 5 == 5
+    assert 10 > 0
+    assert 1 > 2
+    assert 10 * 10 == 100
+    assert 10 * 10 == 101
+  end
+end

callers-context/.iex.exs

@@ -334,3 +334,47 @@ nil
 -   This hygiene seems like a fancy version of just being in or out of scope, perhaps that's the point.
 -   You can override this hygiene by pre-pending `var!`. For example, `if var!(meaning_to_life) == 42 do ....`  
 -   When working with macros, it's important to be aware of what context a macro is executing in and to respect hygiene.
+
+[callers_context.exs](callers-context/callers_context.exs)
+
+<details>
+<summary>callers_context.exs</summary>
+
+```elixir
+defmodule Mod do
+  defmacro definfo do
+    IO.puts("In macro's context (#{__MODULE__}).")
+
+    quote do
+      IO.puts("In caller's context (#{__MODULE__}).")
+
+      def friendly_info do
+        IO.puts("""
+        My name is #{__MODULE__}
+        My functions are #{inspect(__info__(:functions))}
+        """)
+      end
+    end
+  end
+end
+
+defmodule MyModule do
+  require Mod
+  Mod.definfo()
+end
+```
+
+Output:
+
+```elixir
+iex(1)> c "callers_context.exs
+In macro's context (Elixir.Mod).
+In caller's context (Elixir.MyModule).
+[MyModule, Mod]
+
+iex(2)> MyModule.friendly_info
+My name is Elixir.MyModule
+My functions are [friendly_info: 0]
+
+:ok
+```