think links are working and stuff

Dockerfile

···
+# Find eligible builder and runner images on Docker Hub. We use Ubuntu/Debian
+# instead of Alpine to avoid DNS resolution issues in production.
+#
+# https://hub.docker.com/r/hexpm/elixir/tags?page=1&name=ubuntu
+# https://hub.docker.com/_/ubuntu?tab=tags
+#
+# This file is based on these images:
+#
+#   - https://hub.docker.com/r/hexpm/elixir/tags - for the build image
+#   - https://hub.docker.com/_/debian?tab=tags&page=1&name=bullseye-20230612-slim - for the release image
+#   - https://pkgs.org/ - resource for finding needed packages
+#   - Ex: hexpm/elixir:1.15.7-erlang-26.0.2-debian-bullseye-20230612-slim
+#
+ARG ELIXIR_VERSION=1.15.7
+ARG OTP_VERSION=26.0.2
+ARG DEBIAN_VERSION=bullseye-20230612-slim
+
+ARG BUILDER_IMAGE="hexpm/elixir:${ELIXIR_VERSION}-erlang-${OTP_VERSION}-debian-${DEBIAN_VERSION}"
+ARG RUNNER_IMAGE="debian:${DEBIAN_VERSION}"
+
+FROM ${BUILDER_IMAGE} as builder
+
+# Install build dependencies
+RUN apt-get update -y && apt-get install -y build-essential git \
+    && apt-get clean && rm -f /var/lib/apt/lists/*_*
+
+# Prepare build dir
+WORKDIR /app
+
+# Install hex + rebar
+RUN mix local.hex --force && \
+    mix local.rebar --force
+
+# Set build ENV
+ENV MIX_ENV="prod"
+
+# Install mix dependencies
+COPY mix.exs mix.lock ./
+RUN mix deps.get --only $MIX_ENV
+RUN mkdir config
+
+# Copy config/runtime.exs from your project
+COPY config/config.exs config/${MIX_ENV}.exs config/
+RUN mix deps.compile
+
+COPY priv priv
+
+COPY lib lib
+
+COPY assets assets
+
+# Compile assets
+RUN mix assets.deploy
+
+# Compile the release
+RUN mix compile
+
+# Changes to config/runtime.exs don't require recompiling the code
+COPY config/runtime.exs config/
+
+COPY rel rel
+RUN mix release
+
+# Start a new build stage so that the final image will only contain
+# the compiled release and other runtime necessities
+FROM ${RUNNER_IMAGE}
+
+RUN apt-get update -y && apt-get install -y libstdc++6 openssl libncurses5 locales \
+  && apt-get clean && rm -f /var/lib/apt/lists/*_*
+
+# Set the locale
+RUN sed -i '/en_US.UTF-8/s/^# //g' /etc/locale.gen && locale-gen
+
+ENV LANG en_US.UTF-8
+ENV LANGUAGE en_US:en
+ENV LC_ALL en_US.UTF-8
+
+WORKDIR "/app"
+RUN chown nobody /app
+
+# Set runner ENV
+ENV MIX_ENV="prod"
+
+# Only copy the final release from the build stage
+COPY --from=builder --chown=nobody:root /app/_build/${MIX_ENV}/rel/blog ./
+
+USER nobody
+
+CMD ["/app/bin/server"] 

fly.toml

···
+# fly.toml app configuration file generated for thoughts-and-tidbits on 2025-02-01T10:53:39-05:00
+#
+# See https://fly.io/docs/reference/configuration/ for information about how to use this file.
+#
+
+app = "thoughts-and-tidbits"
+primary_region = "ord"
+kill_signal = "SIGTERM"
+
+[build]
+
+[env]
+  PHX_HOST = "thoughts-and-tidbits.fly.dev"
+  PORT = "8080"
+
+[http_service]
+  internal_port = 8080
+  force_https = true
+  auto_stop_machines = true
+  auto_start_machines = true
+  min_machines_running = 0
+  processes = ["app"]
+
+  [http_service.concurrency]
+    type = "connections"
+    hard_limit = 1000
+    soft_limit = 1000
+
+[[vm]]
+  cpu_kind = "shared"
+  cpus = 1
+  memory_mb = 1024

lib/blog/content/post.ex

···
   defstruct [:body, :title, :written_on, :tags, :slug]
 
   def all do
-    "priv/posts/*.md"
+    "priv/static/posts/*.md"
     |> Path.wildcard()
     |> Enum.map(&parse_post_file/1)
     |> Enum.sort_by(& &1.written_on, {:desc, NaiveDateTime})
   end
 
   def get_by_slug(slug) do
-    all()
-    |> Enum.find(&(&1.slug == slug))
+    require Logger
+    all_posts = all()
+    Logger.debug("Looking for slug: #{slug}")
+    Logger.debug("Available slugs: #{inspect(Enum.map(all_posts, & &1.slug))}")
+    Logger.debug("First post for debugging: #{inspect(List.first(all_posts), pretty: true)}")
+
+    found = Enum.find(all_posts, &(&1.slug == slug))
+    Logger.debug("Found post?: #{inspect(found != nil)}")
+    found
   end
 
   defp parse_post_file(file) do
+    require Logger
     filename = Path.basename(file, ".md")
+    Logger.debug("Parsing file: #{filename}")
     [year, month, day, hour, minute, second | title_words] = String.split(filename, "-")
-    _title = Enum.join(title_words, " ")
     datetime = parse_datetime(year, month, day, hour, minute, second)
     slug = Enum.join(title_words, "-")
+    Logger.debug("Generated slug: #{slug}")
 
     %__MODULE__{
       body: File.read!(file),
···
       String.to_integer(minute),
       String.to_integer(second)
     )
-    IO.inspect(datetime, label: "parsed datetime for post")
+    datetime  # Make sure we're returning the datetime
   end
 
   defp humanize_title(slug) do

lib/blog/release.ex

···
+defmodule Blog.Release do
+  @moduledoc """
+  Used for executing DB release tasks when run in production without Mix
+  installed.
+  """
+  @app :blog
+
+  def migrate do
+    load_app()
+
+    for repo <- repos() do
+      {:ok, _, _} = Ecto.Migrator.with_repo(repo, &Ecto.Migrator.run(&1, :up, all: true))
+    end
+  end
+
+  def rollback(repo, version) do
+    load_app()
+    {:ok, _, _} = Ecto.Migrator.with_repo(repo, &Ecto.Migrator.run(&1, :down, to: version))
+  end
+
+  defp repos do
+    Application.fetch_env!(@app, :ecto_repos)
+  end
+
+  defp load_app do
+    Application.load(@app)
+  end
+end

lib/blog_web/components/layouts.ex

···
   def posts_by_tag do
     Blog.Content.Post.all()
     |> Enum.flat_map(fn post ->
-      Enum.map(post.tags, fn tag -> {tag.name, {post.title, format_date(post.written_on), post.slug}} end)
+      Enum.map(post.tags, fn tag -> {tag.name, {post.title, post.slug}} end)
     end)
     |> Enum.group_by(
-      fn {tag_name, _post} -> tag_name end,
-      fn {_tag_name, post} -> post end
+      fn {tag_name, _} -> tag_name end,
+      fn {_, post_info} -> post_info end
     )
     |> Enum.map(fn {tag_name, posts} -> {tag_name, Enum.take(posts, 2)} end)
   end
-
 
   defp format_date(datetime) do
     Calendar.strftime(datetime, "%B %d, %Y")

lib/blog_web/components/layouts/root.html.heex

···
             Posts by Tag
           </h2>
           <%= for {tag, posts} <- posts_by_tag() do %>
-            
             <div class="space-y-6">
               <div class="group">
                 <a href={~p"/post/#{tag}"} class="block">
                   <h3 class="text-sm font-medium text-gray-900 group-hover:text-blue-600 transition-colors">
                     <%= tag %>
                   </h3>
-                  <p class="text-xs text-gray-500 mt-1 font-normal">
-                    <%= for {title, slug} <- posts do %>
-                      <a href={~p"/post/#{slug}"} class="block">
-                        <h6 class="text-sm font-medium text-gray-900 group-hover:text-blue-600 transition-colors">
-                            <%= title %>
-                        </h6>
-                      </a>
-                    <% end %>
-                  </p>
                 </a>
               </div>
             </div>

lib/blog_web/live/index.ex

···
+defmodule BlogWeb.PostLive.Index do
+  use BlogWeb, :live_view
+
+  def mount(_params, _session, socket) do
+    posts = Blog.Content.Post.all()
+    {:ok, assign(socket, posts: posts)}
+  end
+
+  def render(assigns) do
+    ~H"""
+    <div class="px-8 py-12">
+      <div class="max-w-7xl mx-auto">
+        <h1 class="text-4xl font-bold text-gray-900 mb-8">All Posts</h1>
+
+        <div class="space-y-10">
+          <%= for post <- @posts do %>
+            <article class="p-6 bg-white rounded-lg border-2 border-gray-200">
+              <h2 class="text-2xl font-bold text-gray-900 mb-2">
+                <.link href={~p"/post/#{post.slug}"} class="hover:text-blue-600 transition-colors">
+                  <%= post.title %>
+                </.link>
+              </h2>
+
+              <div class="flex items-center space-x-4 text-sm text-gray-500 mb-4">
+                <time datetime={post.written_on}>
+                  <%= Calendar.strftime(post.written_on, "%B %d, %Y") %>
+                </time>
+                <div class="flex items-center space-x-2">
+                  <%= for tag <- post.tags do %>
+                    <span class="inline-flex items-center px-2.5 py-0.5 rounded-full text-xs font-medium bg-gray-100">
+                      <%= tag.name %>
+                    </span>
+                  <% end %>
+                </div>
+              </div>
+
+              <div class="prose prose-lg max-w-none">
+                <%= # Show first paragraph or excerpt %>
+                <%= String.split(post.body, "\n\n") |> List.first() %>
+              </div>
+
+              <div class="mt-4">
+                <.link href={~p"/post/#{post.slug}"} class="text-blue-600 hover:text-blue-800 transition-colors">
+                  Read more →
+                </.link>
+              </div>
+            </article>
+          <% end %>
+        </div>
+      </div>
+    </div>
+    """
+  end
+end

lib/blog_web/live/post_live.ex

···
   use BlogWeb, :live_view
 
   def mount(%{"slug" => slug}, _session, socket) do
+    require Logger
+    Logger.debug("Mounting PostLive with slug: #{slug}")
+
     case Blog.Content.Post.get_by_slug(slug) do
       nil ->
+        Logger.debug("No post found for slug: #{slug}")
         {:ok, push_navigate(socket, to: "/")}
 
       post ->
+        Logger.debug("Found post: #{inspect(post, pretty: true)}")
         case Earmark.as_html(post.body) do
           {:ok, html, _} ->
             headers = extract_headers(post.body)
···
             )
             {:ok, socket}
 
-          {:error, _html, errors} ->
-            # Log the error and show a friendly message
-            require Logger
-            Logger.error("Failed to parse markdown: #{inspect(errors)}")
-            {:ok, push_navigate(socket, to: "/")}
+          {:error, html, errors} ->
+            # Still show the content even if there are markdown errors
+            Logger.error("Markdown parsing warnings: #{inspect(errors)}")
+            headers = extract_headers(post.body)
+            socket = assign(socket,
+              html: html,
+              headers: headers,
+              post: post
+            )
+            {:ok, socket}
         end
     end
   end

priv/static/posts/2024-03-10-14-45-00-pattern-matching-in-elixir.md

···
 
 Posts are routed by slug, which is implicit by title in filename.
 
-For example, `priv/static/posts/2024-03-10-14-45-00-pattern-matching-in-elixir.md` would be `pattern
+For example, `priv/static/posts/2024-03-10-14-45-00-pattern-matching-in-elixir.md` would be routed as `/post/pattern-matching-in-elixir`.

rel/env.sh.eex

···
+#!/bin/sh
+
+# configure node for distributed erlang with IPV6 support
+export ERL_AFLAGS="-proto_dist inet6_tcp"
+export ECTO_IPV6="true"
+export DNS_CLUSTER_QUERY="${FLY_APP_NAME}.internal"
+export RELEASE_DISTRIBUTION="name"
+export RELEASE_NODE="${FLY_APP_NAME}-${FLY_IMAGE_REF##*-}@${FLY_PRIVATE_IP}"
+
+# Uncomment to send crash dumps to stderr
+# This can be useful for debugging, but may log sensitive information
+# export ERL_CRASH_DUMP=/dev/stderr
+# export ERL_CRASH_DUMP_BYTES=4096

rel/overlays/bin/migrate

···
+#!/bin/sh
+set -eu
+
+cd -P -- "$(dirname -- "$0")"
+exec ./blog eval Blog.Release.migrate

rel/overlays/bin/migrate.bat

···
+call "%~dp0\blog" eval Blog.Release.migrate

rel/overlays/bin/server

···
+#!/bin/sh
+set -eu
+
+cd -P -- "$(dirname -- "$0")"
+PHX_SERVER=true exec ./blog start

rel/overlays/bin/server.bat

···
+set PHX_SERVER=true
+call "%~dp0\blog" start