ci: test [skip ci]

Ocultar schema si es de subnivel #14949

See merge request sutty/sutty!240

.dockerignore

@@ -1,10 +1,5 @@
 # Excluir todo
 *
 # Solo agregar lo que usamos en COPY
-!./.git/
-!./rubygems-platform-musl.patch
-!./Gemfile
-!./Gemfile.lock
-!./config/credentials.yml.enc
-!./public/assets-production/
-!./public/packs-production/
+# !./archivo
+!./monit.conf

.editorconfig

@@ -0,0 +1,11 @@
+root = true
+
+[*]
+end_of_line = lf
+insert_final_newline = true
+charset = utf-8
+indent_style = space
+indent_size = 2
+
+[Makefile]
+indent_style = tab

.env

@@ -0,0 +1,43 @@
+NODE_OPTIONS=--openssl-legacy-provider
+# pwgen -1 32
+RAILS_MASTER_KEY=11111111111111111111111111111111
+RAILS_GROUPS=assets
+DELEGATE=panel.sutty.nl
+DATABASE_URL=postgres://suttier@postgresql.sutty.local/sutty
+RAILS_ENV=development
+IMAP_SERVER=
+DEFAULT_FROM=
+EXCEPTION_TO=
+SKEL_SUTTY=https://0xacab.org/sutty/skel.sutty.nl
+# XXX: Si cambiás esta variable, tenés que editar config/webpacker.yml también :(
+SUTTY=sutty.local
+SUTTY_WITH_PORT=sutty.local:3000
+REDIS_SERVER=
+REDIS_CLIENT=
+# API authentication
+HTTP_BASIC_USER=
+HTTP_BASIC_PASSWORD=
+# Blazer
+BLAZER_DATABASE_URL=
+BLAZER_SLACK_WEBHOOK_URL=
+BLAZER_USERNAME=
+BLAZER_PASSWORD=
+# Guardar los formularios enviados como LogEntries
+# @see Api::V1::ProtectedController
+DEBUG_FORMS=
+# Duración de la Cookie de invitade
+# @see Api::V1::ProtectedController
+COOKIE_DURATION=30
+# Dominio de la tienda
+TIENDA=tienda.sutty.local
+# Obtener esto con Site.find_by_name('panel').airbrake_api_key
+PANEL_URL=https://panel.sutty.nl
+AIRBRAKE_SITE_ID=1
+AIRBRAKE_API_KEY=
+GITLAB_URI=https://0xacab.org
+GITLAB_PROJECT=
+GITLAB_TOKEN=
+PGVER=15
+PGPID=/run/postgresql.pid
+PANEL_ACTOR_MENTION=@sutty@sutty.nl
+PANEL_ACTOR_SITE_ID=1

.env.development

@@ -0,0 +1 @@
+HAINISH=../haini.sh/haini.sh

.env.example

@@ -1,24 +0,0 @@
-RAILS_ENV=
-IMAP_SERVER=
-DEFAULT_FROM=
-SKEL_SUTTY=https://0xacab.org/sutty/skel.sutty.nl
-SUTTY=sutty.local
-SUTTY_WITH_PORT=sutty.local:3000
-REDIS_SERVER=
-REDIS_CLIENT=
-# API authentication
-HTTP_BASIC_USER=
-HTTP_BASIC_PASSWORD=
-# Blazer
-BLAZER_DATABASE_URL=
-BLAZER_SLACK_WEBHOOK_URL=
-BLAZER_USERNAME=
-BLAZER_PASSWORD=
-# Guardar los formularios enviados como LogEntries
-# @see Api::V1::ProtectedController
-DEBUG_FORMS=
-# Duración de la Cookie de invitade
-# @see Api::V1::ProtectedController
-COOKIE_DURATION=30
-# Dominio de la tienda
-TIENDA=tienda.sutty.local

.gitattributes

@@ -0,0 +1,2 @@
+public/assets/** filter=lfs diff=lfs merge=lfs -text
+public/packs/** filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -28,18 +28,13 @@
 /data/*
 /_storage/*
 
-.env
+.env.*
 
 # Ignore master key for decrypting credentials and more.
 /config/master.key
 /config/credentials.yml.enc
 
-/public/packs
 /public/packs-test
-/public/assets
-/public/assets-production
-/public/packs
-/public/packs-production
 /node_modules
 /yarn-error.log
 yarn-debug.log*
@@ -49,9 +44,11 @@ yarn-debug.log*
 *.key
 *.crt
 
-/public/packs
-/public/packs-test
 /node_modules
 /yarn-error.log
 yarn-debug.log*
 .yarn-integrity
+
+/.task
+/.yardoc
+/public/doc/

.gitlab-ci.yml

@@ -0,0 +1,124 @@
+.apk-add: &apk-add
+- "apk add go-task diffutils gitlab_ci_log_section"
+.disable-hainish: &disable-hainish
+- "rm -f .env.development"
+.cache-ruby: &cache-ruby
+- paths:
+  - "vendor/ruby"
+  - ".bundle"
+  key:
+    files:
+    - "Gemfile.lock"
+.cache-node: &cache-node
+- paths:
+  - "node_modules"
+  key:
+    files:
+    - "yarn.lock"
+.cache-task: &cache-task
+- paths:
+  - ".task"
+image: "registry.0xacab.org/sutty/sutty:3.17.3-3.1.4-rails"
+variables:
+  RAILS_ENV: "production"
+  LC_ALL: "C.UTF-8"
+  HAINISH: ""
+cache:
+push:
+  stage: "deploy"
+  only:
+  - "rails"
+  except:
+  - "schedules"
+  before_script:
+  - "git config --global user.email \"${GIT_USER_EMAIL:-$GITLAB_USER_EMAIL}\""
+  - "git config --global user.name \"${GIT_USER_NAME:-$GITLAB_USER_NAME}\""
+  - "git remote set-url --push origin \"https://GITLAB_CI_PUSH_TOKEN:${GITLAB_CI_PUSH_TOKEN}@${CI_SERVER_HOST}/${CI_PROJECT_PATH}.git\""
+  script:
+  - "git commit --allow-empty -m \"ci: test [skip ci]\""
+  - "git push -o ci.skip origin HEAD:${CI_COMMIT_BRANCH}"
+assets:
+  stage: "deploy"
+  only:
+  - "rails"
+  - "production.panel.sutty.nl"
+  - "panel.sutty.nl"
+  except:
+  - "schedules"
+  cache:
+  - *cache-ruby
+  - *cache-node
+  - *cache-task
+  before_script:
+  - *apk-add
+  - "gitlab_ci_log_section --name git --header=\"Configuring git\""
+  - "git config --global user.email \"${GIT_USER_EMAIL:-$GITLAB_USER_EMAIL}\""
+  - "git config --global user.name \"${GIT_USER_NAME:-$GITLAB_USER_NAME}\""
+  - "git remote set-url --push origin \"https://GITLAB_CI_PUSH_TOKEN:${GITLAB_CI_PUSH_TOKEN}@${CI_SERVER_HOST}/${CI_PROJECT_PATH}.git\""
+  - "gitlab_ci_log_section --name git --end"
+  - "gitlab_ci_log_section --name apk --header=\"Installing dependencies\""
+  - "apk add brotli"
+  - *disable-hainish
+  - "gitlab_ci_log_section --name apk --end"
+  script:
+  - "gitlab_ci_log_section --name assets --header=\"Building\""
+  - "go-task assets"
+  after_script:
+  - "git add public && git commit -m \"ci: assets [skip ci]\""
+  - "git push -o ci.skip origin HEAD:${CI_COMMIT_BRANCH}"
+gem-audit:
+  stage: "test"
+  only:
+  - "schedules"
+  cache:
+  - *cache-ruby
+  before_script:
+  - *apk-add
+  - *disable-hainish
+  script:
+  - "go-task gem-audit"
+node-audit:
+  stage: "test"
+  only:
+  - "schedules"
+  cache:
+  - *cache-node
+  before_script:
+  - *apk-add
+  - *disable-hainish
+  script:
+  - "apk add go-task"
+  - "go-task node-audit"
+brakeman:
+  stage: "test"
+  cache:
+  - *cache-ruby
+  rules:
+  - if: "$CI_PIPELINE_SOURCE == 'merge_request_event'"
+  before_script:
+  - *apk-add
+  - *disable-hainish
+  script:
+  - "go-task bundle -- exec brakeman"
+rubocop:
+  stage: "test"
+  cache:
+  - *cache-ruby
+  rules:
+  - if: "$CI_PIPELINE_SOURCE == 'merge_request_event'"
+  before_script:
+  - *apk-add
+  - *disable-hainish
+  script:
+  - "go-task rubocop"
+haml:
+  stage: "test"
+  cache:
+  - *cache-ruby
+  rules:
+  - if: "$CI_PIPELINE_SOURCE == 'merge_request_event'"
+  before_script:
+  - *apk-add
+  - *disable-hainish
+  script:
+  - "go-task haml-lint"

.profile

@@ -0,0 +1,9 @@
+Color_Off='\e[0m'
+BPurple='\e[1;35m'
+BBlue='\e[1;34m'
+
+is_git() {
+  git rev-parse --abbrev-ref HEAD 2>/dev/null
+}
+
+PS1="\[${BPurple}\]\$(is_git) \[${BBlue}\]\W\[${Color_Off}\] >_ "

.rubocop.yml

@@ -1,5 +1,6 @@
 AllCops:
   TargetRubyVersion: '2.7'
+  NewCops: enable
 
 Style/AsciiComments:
   Enabled: false

.ruby-version

@@ -1 +0,0 @@
-2.7.1

.woodpecker.yml

@@ -0,0 +1,33 @@
+pipeline:
+  publish:
+    image: "docker.io/woodpeckerci/plugin-docker-buildx"
+    settings:
+      registry: "gitea.nulo.in"
+      username: "sutty"
+      repo: "gitea.nulo.in/sutty/panel"
+      tags:
+      - "${ALPINE_VERSION}-${RUBY_VERSION}.${RUBY_PATCH}-${CI_COMMIT_BRANCH}"
+      - "latest"
+      build_args:
+      - "RUBY_VERSION=${RUBY_VERSION}"
+      - "RUBY_PATCH=${RUBY_PATCH}"
+      - "ALPINE_VERSION=${ALPINE_VERSION}"
+      - "BASE_IMAGE=gitea.nulo.in/sutty/rails"
+      purge: false
+    secrets:
+    - "DOCKER_PASSWORD"
+    when:
+      branch:
+      - "rails"
+      - "17.3.alpine.panel.sutty.nl"
+      event: "push"
+      path:
+        include:
+        - "Dockerfile"
+        - ".dockerignore"
+        - ".woodpecker.yml"
+matrix:
+  include:
+  - ALPINE_VERSION: "3.17.3"
+    RUBY_VERSION: "3.1"
+    RUBY_PATCH: "4"

Dockerfile

@@ -1,130 +1,30 @@
-# Este Dockerfile está armado pensando en una compilación lanzada desde
-# el mismo repositorio de trabajo.  Cuando tengamos CI/CD algunas cosas
-# como el tarball van a tener que cambiar porque ya vamos a haber hecho
-# un clone/pull limpio.
-FROM alpine:3.12 AS build
-MAINTAINER "f <f@sutty.nl>"
-
-ARG RAILS_MASTER_KEY
-
-# Un entorno base
-ENV SECRET_KEY_BASE solo_es_necesaria_para_correr_rake
+ARG RUBY_VERSION=3.1
+ARG RUBY_PATCH=4
+ARG ALPINE_VERSION=3.17.3
+ARG BASE_IMAGE=registry.nulo.in/sutty/rails
+FROM ${BASE_IMAGE}:${ALPINE_VERSION}-${RUBY_VERSION}.${RUBY_PATCH}
+ARG PANDOC_VERSION=2.18
 ENV RAILS_ENV production
-ENV RAILS_MASTER_KEY=$RAILS_MASTER_KEY
-
-RUN apk add --no-cache libxslt libxml2 tzdata ruby ruby-bundler ruby-json ruby-bigdecimal ruby-rake
-RUN apk add --no-cache postgresql-libs git yarn brotli libssh2 python3
-
-RUN test "2.7.1" = `ruby -e 'puts RUBY_VERSION'`
-
-# https://github.com/rubygems/rubygems/issues/2918
-# https://gitlab.alpinelinux.org/alpine/aports/issues/10808
-RUN apk add --no-cache patch
-COPY ./rubygems-platform-musl.patch /tmp/
-RUN cd /usr/lib/ruby/2.7.0 && patch -Np 0 -i /tmp/rubygems-platform-musl.patch
-
-# Agregar el usuario
-RUN addgroup -g 82 -S www-data
-RUN adduser -s /bin/sh -G www-data -h /home/app -D app
-RUN install -dm750 -o app -g www-data /home/app/sutty
-RUN gem install --no-document bundler
-
-# Empezamos con la usuaria app
-USER app
-# Vamos a trabajar dentro de este directorio
-WORKDIR /home/app/sutty
-
-# Copiamos solo el Gemfile para poder instalar las gemas necesarias
-COPY --chown=app:www-data ./Gemfile .
-COPY --chown=app:www-data ./Gemfile.lock .
-RUN bundle config set no-cache 'true'
-RUN bundle install --path=./vendor --without='test development'
-# Vaciar la caché
-RUN rm vendor/ruby/2.7.0/cache/*.gem
-
-# Copiar el repositorio git
-COPY --chown=app:www-data ./.git/ ./.git/
-# Hacer un clon limpio del repositorio en lugar de copiar todos los
-# archivos
-RUN cd .. && git clone sutty checkout
-
-WORKDIR /home/app/checkout
-# Traer las gemas:
-RUN mv ../sutty/vendor ./vendor
-RUN mv ../sutty/.bundle ./.bundle
-
-# Instalar secretos
-COPY --chown=app:root ./config/credentials.yml.enc ./config/
-# Traer los assets pre-compilados
-COPY --chown=app:www-data ./public/assets-production ./public/assets
-COPY --chown=app:www-data ./public/packs-production ./public/packs
-
-# Eliminar la necesidad de un runtime JS en producción, porque los
-# assets ya están pre-compilados.
-RUN sed -re "/(sassc|uglifier|bootstrap|coffee-rails)/d" -i Gemfile
-RUN bundle clean
-RUN rm -rf ./node_modules ./tmp/cache ./.git ./test ./doc
-# Eliminar archivos innecesarios
-USER root
-RUN apk add --no-cache findutils
-RUN find /home/app/checkout/vendor/ruby/2.7.0 -maxdepth 3 -type d -name test -o -name spec -o -name rubocop | xargs -r rm -rf
-RUN cd /home/app/checkout/vendor/ruby/2.7.0/gems/prometheus_exporter-0.5.3 && patch -Np 0 -i /home/app/checkout/prom.patch
-
-# Contenedor final
-FROM sutty/monit:latest
-ENV RAILS_ENV production
-
-# Pandoc
-RUN echo 'http://dl-cdn.alpinelinux.org/alpine/edge/testing' >> /etc/apk/repositories
 
 # Instalar las dependencias, separamos la librería de base de datos para
 # poder reutilizar este primer paso desde otros contenedores
-RUN apk add --no-cache libxslt libxml2 tzdata ruby ruby-bundler ruby-json ruby-bigdecimal ruby-rake ruby-irb
-RUN apk add --no-cache postgresql-libs libssh2 file rsync git jpegoptim vips
-RUN apk add --no-cache ffmpeg imagemagick pandoc tectonic oxipng jemalloc
-RUN apk add --no-cache git-lfs
-
-# Chequear que la versión de ruby sea la correcta
-RUN test "2.7.1" = `ruby -e 'puts RUBY_VERSION'`
-
-# https://github.com/rubygems/rubygems/issues/2918
-# https://gitlab.alpinelinux.org/alpine/aports/issues/10808
-COPY ./rubygems-platform-musl.patch /tmp/
-RUN apk add --no-cache patch && cd /usr/lib/ruby/2.7.0 && patch -Np 0 -i /tmp/rubygems-platform-musl.patch && apk del patch
-
+#
 # Necesitamos yarn para que Jekyll pueda generar los sitios
 # XXX: Eliminarlo cuando extraigamos la generación de sitios del proceso
 # principal
-RUN apk add --no-cache yarn
-# Instalar foreman para poder correr los servicios
-RUN gem install --no-document --no-user-install bundler foreman
+RUN apk add --no-cache libxslt libxml2 postgresql-libs libssh2 \
+      rsync git jpegoptim vips tectonic oxipng git-lfs openssh-client \
+      yarn daemonize ruby-webrick postgresql-client dateutils file
 
-# Agregar el grupo del servidor web y la usuaria
-RUN addgroup -g 82 -S www-data
-RUN adduser -s /bin/sh -G www-data -h /srv/http -D app
+RUN gem install --no-document --no-user-install foreman
+RUN wget https://github.com/jgm/pandoc/releases/download/${PANDOC_VERSION}/pandoc-${PANDOC_VERSION}-linux-amd64.tar.gz -O - | tar --strip-components 1 -xvzf - pandoc-${PANDOC_VERSION}/bin/pandoc && mv /bin/pandoc /usr/bin/pandoc
+RUN apk add npm && npm install -g pnpm@~7 && apk del npm
 
-# Convertirse en app para instalar
-USER app
-COPY --from=build --chown=app:www-data /home/app/checkout /srv/http
-RUN rm -rf /srv/http/_sites /srv/http/_deploy
-RUN ln -s data/_storage /srv/http/_storage
-RUN ln -s data/_sites /srv/http/_sites
-RUN ln -s data/_deploy /srv/http/_deploy
-RUN ln -s data/_public /srv/http/_public
-RUN ln -s data/_private /srv/http/_private
+COPY ./monit.conf /etc/monit.d/sutty.conf
 
-# Volver a root para cerrar la compilación
-USER root
-# Sincronizar los assets a un directorio compartido
-RUN install -m 755 /srv/http/sync_assets.sh /usr/local/bin/sync_assets
-# Instalar la configuración de monit
-RUN install -m 640 -o root -g root /srv/http/monit.conf /etc/monit.d/sutty.conf
-RUN apk add --no-cache daemonize ruby-webrick
-RUN install -m 755 /srv/http/entrypoint.sh /usr/local/bin/sutty
+RUN apk add npm && npm install -g pnpm && apk del npm
 
-# Mantener estos directorios!
-VOLUME "/srv/http/data"
+VOLUME "/srv"
 
-# El puerto de puma
 EXPOSE 3000
 EXPOSE 9394

Gemfile

@@ -1,35 +1,26 @@
 # frozen_string_literal: true
 
-# TODO: Podríamos usar solo gems.sutty.nl pero por alguna razón bundler
-# prefiere x86_64-linux-musl antes que x86_64-linux y ya perdimos mucho
-# tiempo buscando soporte para musl
-if ENV['RAILS_ENV'] == 'production'
-  source 'https://gems.sutty.nl'
-else
-  source 'https://rubygems.org'
-end
+source ENV.fetch('GEMS_SOURCE', 'https://17.3.alpine.gems.sutty.nl')
 
-git_source(:github) do |repo_name|
-  repo_name = "#{repo_name}/#{repo_name}" unless repo_name.include?('/')
-  "https://github.com/#{repo_name}.git"
-end
-
-# Cambiar en Dockerfile también
-ruby '2.7.1'
-
-gem 'dotenv-rails', require: 'dotenv/rails-now'
+ruby "~> #{ENV.fetch('RUBY_VERSION', '3.1')}"
 
 # Bundle edge Rails instead: gem 'rails', github: 'rails/rails'
-gem 'rails', '~> 6'
+gem 'rails', '~> 6.1.0'
 # Use Puma as the app server
 gem 'puma'
-# See https://github.com/rails/execjs#readme for more supported runtimes
-# gem 'therubyracer', platforms: :ruby
-# Use SCSS for stylesheets
-gem 'sassc-rails'
-# Use Uglifier as compressor for JavaScript assets
-gem 'uglifier', '>= 1.3.0'
-gem 'bootstrap', '~> 4'
+
+# Solo incluir las gemas cuando estemos en desarrollo o compilando los
+# assets.  No es necesario instalarlas en producción.
+#
+# XXX: Supuestamente Rails ya soporta RAILS_GROUPS, pero Bundler no.
+if ENV['RAILS_GROUPS']&.split(',')&.include? 'assets'
+  gem 'sassc-rails'
+  gem 'uglifier', '>= 1.3.0'
+  gem 'bootstrap', '~> 4'
+end
+
+gem 'nokogiri'
+gem 'rgl'
 
 # Turbolinks makes navigating your web application faster. Read more:
 # https://github.com/turbolinks/turbolinks
@@ -39,12 +30,17 @@ gem 'turbolinks', '~> 5'
 gem 'jbuilder', '~> 2.5'
 # Use ActiveModel has_secure_password
 gem 'bcrypt', '~> 3.1.7'
+gem 'safely_block', '~> 0.3.0'
 gem 'blazer'
+gem 'chartkick'
 gem 'commonmarker'
 gem 'devise'
 gem 'devise-i18n'
 gem 'devise_invitable'
-gem 'email_address'
+gem 'redis-client'
+gem 'hiredis-client'
+gem 'distributed-press-api-client', '~> 0.4.1'
+gem 'email_address', git: 'https://github.com/fauno/email_address', branch: 'i18n'
 gem 'exception_notification'
 gem 'fast_blank'
 gem 'friendly_id'
@@ -53,31 +49,47 @@ gem 'hiredis'
 gem 'image_processing'
 gem 'icalendar'
 gem 'inline_svg'
-gem 'jekyll', git: 'https://0xacab.org/sutty/jekyll/jekyll.git',
-              branch: 'master'
-gem 'jekyll-data', require: 'jekyll-data',
-                   git: 'https://0xacab.org/sutty/jekyll/jekyll-data.git'
-gem 'jekyll-commonmark'
+gem 'httparty'
+gem 'safe_yaml', require: false
+gem 'jekyll', '~> 4.2.0'
+gem 'jekyll-commonmark', '~> 1.4.0'
 gem 'jekyll-images'
 gem 'jekyll-include-cache'
-gem 'sutty-liquid'
+gem 'sutty-liquid', '>= 0.7.3'
+gem 'loaf'
 gem 'lockbox'
 gem 'mini_magick'
 gem 'mobility'
-gem 'pg'
 gem 'pundit'
 gem 'rails-i18n'
 gem 'rails_warden'
-gem 'redis', require: %w[redis redis/connection/hiredis]
+gem 'redis', '~> 4.0', require: %w[redis redis/connection/hiredis]
 gem 'redis-rails'
+gem 'rollups', git: 'https://github.com/fauno/rollup.git', branch: 'update'
 gem 'rubyzip'
-gem 'rugged'
-gem 'sucker_punch'
+gem 'ruby-brs'
+gem 'rugged', '1.5.0.1'
+gem 'git_clone_url'
+gem 'concurrent-ruby-ext'
+gem 'que'
 gem 'symbol-fstring', require: 'fstring/all'
 gem 'terminal-table'
 gem 'validates_hostname'
 gem 'webpacker'
 gem 'yaml_db', git: 'https://0xacab.org/sutty/yaml_db.git'
+gem 'kaminari'
+gem 'device_detector'
+gem 'dry-schema'
+gem 'rubanok'
+
+gem 'after_commit_everywhere', '~> 1.0'
+gem 'aasm'
+gem 'que-web'
+
+# database
+gem 'hairtrigger'
+gem 'pg'
+gem 'pg_search'
 
 # performance
 gem 'flamegraph'
@@ -86,17 +98,16 @@ gem 'rack-mini-profiler'
 gem 'stackprof'
 gem 'prometheus_exporter'
 
-group :themes do
-  gem 'adhesiones-jekyll-theme', require: false
-  gem 'editorial-autogestiva-jekyll-theme', require: false
-  gem 'minima', require: false
-  gem 'sutty-minima', require: false
-  gem 'radios-comunitarias-jekyll-theme', require: false
-  gem 'share-to-fediverse-jekyll-theme', require: false
-  gem 'sutty-donaciones-jekyll-theme', require: false
-  gem 'sutty-jekyll-theme', require: false
-  gem 'recursero-jekyll-theme', require: false
-end
+# debug
+gem 'fast_jsonparser', '~> 0.5.0'
+gem 'down'
+gem 'sourcemap'
+gem 'rack-cors'
+
+# ssh
+gem 'net-ssh'
+gem 'ed25519'
+gem 'bcrypt_pbkdf'
 
 group :production do
   gem 'lograge'
@@ -104,22 +115,25 @@ end
 
 group :development, :test do
   gem 'derailed_benchmarks'
+  gem 'dotenv-rails'
   gem 'pry'
   # Adds support for Capybara system testing and selenium driver
   gem 'capybara', '~> 2.13'
-  gem 'selenium-webdriver'
+  gem 'selenium-webdriver', '~> 4.8.0'
   gem 'sqlite3'
 end
 
 group :development do
+  gem 'yard'
   gem 'brakeman'
+  gem 'bundler-audit'
   gem 'haml-lint', require: false
   gem 'letter_opener'
-  gem 'listen', '>= 3.0.5', '< 3.2'
+  gem 'listen'
   gem 'rubocop-rails'
   gem 'spring'
-  gem 'spring-watcher-listen', '~> 2.0.0'
-  gem 'web-console', '>= 3.3.0'
+  gem 'spring-watcher-listen'
+  gem 'web-console'
 end
 
 group :test do

Makefile

@@ -1,88 +0,0 @@
-# Incluir las variables de entorno
-mkfile_path := $(abspath $(lastword $(MAKEFILE_LIST)))
-root_dir := $(patsubst %/,%,$(dir $(mkfile_path)))
-include $(root_dir)/.env
-
-delegate := athshe
-
-assets := package.json yarn.lock $(shell find app/assets/ app/javascript/ -type f)
-
-alpine_version := 3.12
-
-public/assets-production/: $(assets)
-	RAILS_ENV=production bundle exec rake assets:precompile assets:clean
-	rsync --delete-after -a public/assets/ $@
-
-public/packs-production/: public/packs/
-	rsync -a --delete-after $< $@
-
-assets: public/assets-production/ public/packs-production/
-
-serve:
-	bundle exec rails s -b "ssl://0.0.0.0:3000?key=../sutty.local/domain/sutty.local.key&cert=../sutty.local/domain/sutty.local.crt"
-
-# Limpiar los archivos de testeo
-clean:
-	rm -rf _sites/test-* _deploy/test-*
-
-# Generar la imagen Docker
-build: assets
-	time docker build --build-arg="RAILS_MASTER_KEY=`cat config/master.key`" -t sutty/sutty .
-	docker tag sutty/sutty:latest sutty:keep
-
-save:
-	time docker save sutty/sutty:latest | ssh root@$(delegate).sutty.nl docker load
-	date +%F | xargs git tag -f 
-
-load:
-	ssh root@sutty.nl sh -c "gunzip -c sutty.latest.gz | docker load"
-
-# Crear el directorio donde se almacenan las gemas binarias
-../gems/:
-	mkdir -p $@
-
-gem_dir := $(shell readlink -f ../gems)
-ifeq ($(MAKECMDGOALS),build-gems)
-gems := $(shell bundle show --paths | xargs -I {} sh -c 'test -f {}/ext/*/extconf.rb && basename {}')
-gems += $(shell bundle show --paths | xargs -I {} sh -c 'test -f {}/ext/extconf.rb && basename {}')
-gems := $(patsubst %,$(gem_dir)/cache/%.gem,$(gems))
-gems_musl := $(patsubst $(gem_dir)/cache/%.gem,$(gem_dir)/$(alpine_version)/%-x86_64-linux-musl.gem,$(gems))
-endif
-
-$(gem_dir)/%-x86_64-linux-musl.gem:
-	@docker run \
-		-v $(gem_dir):/srv/gems \
-		-v `readlink -f ~/.ccache`:/home/builder/.ccache \
-		-e HTTP_BASIC_USER=$(HTTP_BASIC_USER) \
-		-e HTTP_BASIC_PASSWORD=$(HTTP_BASIC_PASSWORD) \
-		-e GEM=`echo $(notdir $*) | sed -re "s/-[^-]+$$//"` \
-		-e VERSION=`echo $(notdir $*) | sed -re "s/.*-([^-]+)$$/\1/"` \
-		-e JOBS=2 \
-		--rm -it \
-		sutty/gem-compiler:latest || echo "No se pudo compilar $*"
-
-# Compilar todas las gemas binarias y subirlas a gems.sutty.nl para que
-# al crear el contenedor no tengamos que compilarlas cada vez
-build-gems: $(gems_musl)
-
-cached_gems  = $(wildcard $(gem_dir)/cache/*.gem)
-rebuild_gems = $(patsubst $(gem_dir)/cache/%.gem,$(gem_dir)/$(alpine_version)/%-x86_64-linux-musl.gem,$(cached_gems))
-rebuild-gems: $(rebuild_gems)
-
-dirs := $(patsubst %,root/%,data sites deploy public)
-
-$(dirs):
-	mkdir -p $@
-
-test-container: $(dirs)
-	docker run -v $(PWD)/root/data:/srv/http/data \
-	           -v $(PWD)/root/sites:/srv/http/_sites \
-	           -v $(PWD)/root/deploy:/srv/http/_deploy \
-	           -v $(PWD)/root/public:/srv/http/_public \
-	           -v $(PWD)/config/credentials.yml.enc:/srv/http/config/credentials.yml.enc \
-	           -e RAILS_MASTER_KEY=`cat config/master.key` \
-						 -e RAILS_ENV=production \
-						 -it \
-	           --rm \
-	           --name=sutty \
-	           sutty/sutty /bin/sh

Procfile

@@ -5,3 +5,9 @@ blazer_1h: bundle exec rake blazer:run_checks SCHEDULE="1 hour"
 blazer_1d: bundle exec rake blazer:run_checks SCHEDULE="1 day"
 blazer: bundle exec rake blazer:send_failing_checks
 prometheus: bundle exec prometheus_exporter -b 0.0.0.0 --prefix "sutty_"
+distributed_press_tokens_renew: bundle exec rake distributed_press:tokens:renew
+cleanup: bundle exec rake cleanup:everything
+emergency_cleanup: bundle exec rake cleanup:everything BEFORE=7
+stats: bundle exec rake stats:process_all
+que: daemonize -c /srv/ -p /srv/tmp/que.pid -u rails /usr/local/bin/syslogize bundle exec que
+fediblock: bundle exec rails activity_pub:fediblocks

README.md

@@ -15,6 +15,35 @@ Este repositorio es la plataforma _Ruby on Rails_ para alojar el
 
 Para más información visita el [sitio de Sutty](https://sutty.nl/).
 
+### Desarrollar
+
+Para facilitar la gestión de dependencias y entorno de desarrollo,
+instala [haini.sh](https://0xacab.org/sutty/haini.sh)
+
+
+Todas las tareas se gestionan con `go-task`.  [Instrucciones de
+instalación (en inglés)](https://taskfile.dev/installation/)
+
+```bash
+go-task
+```
+
+### Variables de entorno
+
+Las variables de entorno por defecto se encuentran en el archivo `.env`.
+Para modificar las opciones, crear o modificar el archivo `.env.local`
+con valores distintos.
+
+### Documentación
+
+Para navegar la documentación del código usando YARD:
+
+```bash
+go-task doc serve
+```
+
+Y luego navegar a <https://panel.sutty.local:3000/doc/>
+
 ## English
 
 Sutty is a platform for hosting safer, faster and more resilient
@@ -25,3 +54,32 @@ This repository is the Ruby on Rails platform that hosts the
 self-managed [panel](https://panel.sutty.nl/).
 
 For more information, visit [Sutty's website](https://sutty.nl/en/).
+
+### Development
+
+
+To facilitate dependencies and dev environment, install
+[haini.sh](https://0xacab.org/sutty/haini.sh)
+
+Every task is run via `go-task`.  [Installation
+instructions](https://taskfile.dev/installation/).
+
+```bash
+go-task
+```
+
+### Environment variables
+
+Default env vars are store on `.env`.  For local options, copy them to
+`.env.local`.
+
+### Documentation
+
+To browse documentation using YARD:
+
+```bash
+go-task doc serve
+```
+
+And then open <https://panel.sutty.local:3000/doc/>
+

Taskfile.yaml

@@ -0,0 +1,197 @@
+---
+version: "3"
+vars:
+  CURRENT_BRANCH:
+    sh: "git rev-parse --abbrev-ref HEAD"
+shopt:
+- "globstar"
+dotenv:
+- ".env.development"
+- ".env"
+- ".env.local"
+- ".env.development.local"
+tasks:
+  credentials:
+    desc: "Generate credentials file"
+    cmds:
+    - "cp --no-clobber config/credentials.yml.enc.ci config/credentials.yml.enc"
+    sources:
+    - "config/credentials.yml.enc.ci"
+    generates:
+    - "config/credentials.yml.enc"
+  gems:
+    desc: "Install gems"
+    deps:
+    - "credentials"
+    cmds:
+    - "{{.HAINISH}} bundle config set --local path './vendor'"
+    - "{{.HAINISH}} bundle install"
+    sources:
+    - "Gemfile"
+    generates:
+    - "Gemfile.lock"
+    status:
+    - "test -d vendor/ruby"
+  clean:
+    desc: "Clean"
+    cmds:
+    - "rm -rf _sites/test-* _deploy/test-* log/*.log tmp/cache tmp/letter_opener tmp/miniprofiler tmp/storage"
+  node-modules:
+    desc: "Install Node modules"
+    cmds:
+    - "{{.HAINISH}} yarn"
+    sources:
+    - "package.json"
+    - "yarn.lock"
+    status:
+    - "test -d node_modules"
+  assets:
+    desc: "Generate assets"
+    deps:
+    - "node-modules"
+    - "gems"
+    cmds:
+    - "git lfs fetch"
+    - "git lfs checkout"
+    - task: "rails"
+      vars:
+        CLI_ARGS: "webpacker:clobber RAILS_ENV=production"
+    - task: "rails"
+      vars:
+        CLI_ARGS: "assets:precompile RAILS_ENV=production"
+    - task: "rails"
+      vars:
+        CLI_ARGS: "assets:clean RAILS_ENV=production"
+    sources:
+    - "package.json"
+    - "yarn.lock"
+    - "app/assets/**/*"
+    - "app/javascript/**/*"
+    generates:
+    - "public/packs/manifest.json"
+  hosts:
+    desc: "Local DNS resolution for hostnames"
+    interactive: true
+    cmds:
+    - "echo -e \"127.0.0.1 panel.{{.SUTTY}} api.{{.SUTTY}} postgresql.{{.SUTTY}}\" | sudo tee -a /etc/hosts"
+    - "echo -e \"::1 panel.{{.SUTTY}} api.{{.SUTTY}} postgresql.{{.SUTTY}}\" | sudo tee -a /etc/hosts"
+    status:
+    - "grep -q \" panel.{{.SUTTY}} \" /etc/hosts"
+  database-init:
+    desc: "Database install"
+    cmds:
+    - "{{.HAINISH}} /usr/bin/initdb --locale en_US.utf8 -E UTF8 -D /var/lib/postgresql/{{.PGVER}}/data"
+    - "echo \"host all all samenet trust\" >> ../hain/var/lib/postgresql/{{.PGVER}}/data/pg_hba.conf"
+    - "echo \"listen_addresses = '*'\" >> ../hain/var/lib/postgresql/{{.PGVER}}/data/postgresql.conf"
+    - "echo \"external_pid_file = '{{.PGPID}}'\" >> ../hain/var/lib/postgresql/{{.PGVER}}/data/postgresql.conf"
+    - "install -dm755 ../hain/run/postgresql"
+    status:
+    - "test -d ../hain/var/lib/postgresql/{{.PGVER}}/data"
+    - "test -f ../hain/var/lib/postgresql/{{.PGVER}}/data/postgresql.conf"
+  database:
+    desc: "Database"
+    deps:
+    - "database-init"
+    cmds:
+    - "{{.HAINISH}} daemonize -c /var/lib/postgresql/{{.PGVER}}/data /usr/bin/postgres -D /var/lib/postgresql/{{.PGVER}}/data"
+    status:
+    - "test -f ../hain{{.PGPID}}"
+    - "pgrep -F ../hain{{.PGPID}}"
+  prepare:
+    desc: "Create database or run pending migrations"
+    deps:
+    - "database"
+    cmds:
+    - task: "rails"
+      vars:
+        CLI_ARGS: "db:prepare"
+  serve:
+    desc: "Run Rails development server"
+    deps:
+    - "prepare"
+    - "gems"
+    cmds:
+    - ": == Development server running at https://panel.{{.SUTTY_WITH_PORT}} =="
+    - task: "rails"
+      vars:
+        CLI_ARGS: "server"
+    status:
+    - "test -f tmp/pids/server.pid"
+    - "pgrep -F tmp/pids/server.pid"
+  yarn:
+    desc: "Yarn. Call with: go-task yarn -- arguments"
+    deps:
+    - "node-modules"
+    cmds:
+    - "{{.HAINISH}} yarn {{.CLI_ARGS}}"
+    - defer:
+        task: "notify"
+  bundle:
+    desc: "Bundle. Call with: go-task bundle -- arguments"
+    interactive: true
+    deps:
+    - "gems"
+    cmds:
+    - "{{.HAINISH}} bundle {{.CLI_ARGS}}"
+    - defer:
+        task: "notify"
+  rails:
+    desc: "Rails. Call with: go-task rails -- arguments"
+    cmds:
+    - task: "bundle"
+      vars:
+        CLI_ARGS: "exec rails {{.CLI_ARGS}}"
+  console:
+    desc: "Rails console"
+    interactive: true
+    cmds:
+    - task: "rails"
+      vars:
+        CLI_ARGS: "console"
+  doc:
+    desc: "Build documentation"
+    deps:
+    - "gems"
+    cmds:
+    - task: "bundle"
+      vars:
+        CLI_ARGS: "exec yardoc -o public/doc app lib config db"
+  gem-audit:
+    desc: "Audit Gem dependencies"
+    deps:
+    - "gems"
+    - "bundler-audit"
+    cmds:
+    - task: "bundle"
+      vars:
+        CLI_ARGS: "audit --update"
+  node-audit:
+    desc: "Audit Node dependencies"
+    deps:
+    - "node-modules"
+    cmds:
+    - task: "yarn"
+      vars:
+        CLI_ARGS: "audit"
+  notify:
+    internal: true
+    cmds:
+    - "echo -e \"\a\""
+  bundler-audit:
+    internal: true
+    cmds:
+    - "{{.HAINISH}} gem install bundler-audit"
+    status:
+    - "test -f ../hain/usr/bin/bundler-audit"
+  rubocop:
+    desc: "Ruby linting"
+    deps:
+    - "gems"
+    cmds:
+    - "./bin/modified_files | ./bin/with_extension rb | xargs -r {{.HAINISH}} bundle exec rubocop {{.CLI_ARGS}}"
+  haml-lint:
+    desc: "HAML linting"
+    deps:
+    - "gems"
+    cmds:
+    - "./bin/modified_files | ./bin/with_extension haml | xargs -r {{.HAINISH}} bundle exec haml-lint {{.CLI_ARGS}}"

app/assets/javascripts/01-types.js

@@ -1,422 +0,0 @@
-function setAuxiliaryToolbar (editorEl, toolbarName) {
-	const toolbarEl = editorEl.querySelector(`*[data-editor-auxiliary-toolbar]`)
-	for (const otherEl of toolbarEl.childNodes) {
-		if (otherEl.nodeType !== Node.ELEMENT_NODE) continue
-		otherEl.classList.remove("editor-auxiliary-tool-active")
-	}
-	if (toolbarName) {
-		const auxEl = editorEl.querySelector(`*[data-editor-auxiliary="${toolbarName}"]`)
-		auxEl.classList.add("editor-auxiliary-tool-active")
-	}
-}
-
-const marks = {
-	bold: {
-		selector: "strong",
-		createFn: () => document.createElement("STRONG"),
-	},
-	italic: {
-		selector: "em",
-		createFn: () => document.createElement("EM"),
-	},
-	deleted: {
-		selector: "del",
-		createFn: () => document.createElement("DEL"),
-	},
-	underline: {
-		selector: "u",
-		createFn: () => document.createElement("U"),
-	},
-	sub: {
-		selector: "sub",
-		createFn: () => document.createElement("SUB"),
-	},
-	sup: {
-		selector: "sup",
-		createFn: () => document.createElement("SUP"),
-	},
-	mark: {
-		selector: "mark",
-		createFn: () => document.createElement("MARK"),
-	},
-	a: {
-		selector: "a",
-		createFn: () => document.createElement("A"),
-	}
-}
-
-const tagNameSetFn = tagName => el => {
-	const newEl = document.createElement(tagName)
-	moveChildren(el, newEl, null)
-	el.parentNode.insertBefore(newEl, el)
-	el.parentNode.removeChild(el)
-	window.getSelection().collapse(newEl, 0)
-}
-
-const blocks = {
-	p: {
-		noButton: true,
-		selector: "P",
-		setFn: tagNameSetFn("P"),
-	},
-	h1: {
-		selector: "H1",
-		setFn: tagNameSetFn("H1"),
-	},
-	h2: {
-		selector: "H2",
-		setFn: tagNameSetFn("H2"),
-	},
-	h3: {
-		selector: "H3",
-		setFn: tagNameSetFn("H3"),
-	},
-	h4: {
-		selector: "H4",
-		setFn: tagNameSetFn("H4"),
-	},
-	h5: {
-		selector: "H5",
-		setFn: tagNameSetFn("H5"),
-	},
-	h6: {
-		selector: "H6",
-		setFn: tagNameSetFn("H6"),
-	},
-	ul: {
-		selector: "UL",
-		setFn: tagNameSetFn("UL"),
-	},
-	ol: {
-		selector: "OL",
-		setFn: tagNameSetFn("OL"),
-	},
-	img: {
-		selector: "IMG",
-		createFn: editorEl => {
-			const el = document.createElement("IMG")
-			el.src = "/placeholder.png"
-			el.alt = ""
-			return el
-		},
-	},
-	figure: {
-		selector: "FIGURE",
-		noButton: true
-	},
-	figcaption: {
-		selector: "FIGCAPTION",
-		noButton: true,
-	},
-	audio: {
-		selector: "AUDIO",
-		createFn: editorEl => {
-			const el = document.createElement("FIGURE")
-
-			el.appendChild(document.createElement("AUDIO"))
-			el.appendChild(document.createElement("FIGCAPTION"))
-
-			el.children[0].controls = true
-			el.children[1].innerText = "Toca el borde para subir un archivo de audio"
-
-			return el
-		},
-	},
-	video: {
-		selector: "VIDEO",
-		createFn: editorEl => {
-			const el = document.createElement("VIDEO")
-			el.poster = "/placeholder.png"
-			// Para poder seleccionar el video tenemos que sacarle los
-			// controles, pero queremos poder verlos para reproducir el video.
-			// Al hacer click le damos los controles y al salir se los sacamos
-			// para poder hacer click de vuelta
-			el.addEventListener('click', event => event.target.controls = true)
-			el.addEventListener('focusout', event => event.target.controls = false)
-			return el
-		},
-	},
-	// PDF
-	pdf: {
-		selector: "IFRAME",
-		createFn: editorEl => {
-			const el = document.createElement("FIGURE")
-
-			el.appendChild(document.createElement("IFRAME"))
-			el.appendChild(document.createElement("FIGCAPTION"))
-
-			el.children[1].innerText = "Toca el borde para subir un archivo PDF"
-
-			return el
-		},
-	},
-}
-
-const divWithStyleCreateFn = styleFn => () => {
-	const el = document.createElement("DIV")
-	styleFn(el)
-	return el
-}
-
-const parentBlocks = {
-	left: {
-		selector: "div[data-align=left]",
-		createFn: divWithStyleCreateFn(el => el.dataset.align = "left"),
-	},
-	center: {
-		selector: "div[data-align=center]",
-		createFn: divWithStyleCreateFn(el => el.dataset.align = "center"),
-	},
-	right: {
-		selector: "div[data-align=right]",
-		createFn: divWithStyleCreateFn(el => el.dataset.align = "right"),
-	},
-}
-
-// https://stackoverflow.com/a/3627747
-// TODO: cambiar por una solución más copada
-function rgb2hex(rgb) {
-	rgb = rgb.match(/^rgb\((\d+),\s*(\d+),\s*(\d+)\)$/);
-	function hex(x) {
-		return ("0" + parseInt(x).toString(16)).slice(-2);
-	}
-	return "#" + hex(rgb[1]) + hex(rgb[2]) + hex(rgb[3]);
-}
-
-const getSelected = contentEl => contentEl.querySelector(".selected")
-
-const typesWithProperties = {
-	a: {
-		selector: marks.a.selector,
-		updateInput (el, editorEl) {
-			setAuxiliaryToolbar(editorEl, "a")
-
-			const markAInputEl = editorEl.querySelector(`*[data-prop="a-href"]`)
-			markAInputEl.disabled = false
-			markAInputEl.value = el.href
-		},
-		disableInput (editorEl) {
-			const markAInputEl = editorEl.querySelector(`*[data-prop="a-href"]`)
-			markAInputEl.disabled = true
-			markAInputEl.value = ""
-		},
-		setupInput (editorEl, contentEl) {
-			const markAInputEl = editorEl.querySelector(`*[data-prop="a-href"]`)
-			markAInputEl.addEventListener("change", event => {
-				const markEl = contentEl.querySelector(marks.a.selector + ".selected")
-				if (markEl) markEl.href = markAInputEl.value
-			}, false)
-		}
-	},
-	mark: {
-		selector: marks.mark.selector,
-		updateInput (el, editorEl) {
-			setAuxiliaryToolbar(editorEl, "mark")
-
-			const markColorInputEl = editorEl.querySelector(`*[data-prop="mark-color"]`)
-			markColorInputEl.disabled = false
-			markColorInputEl.value = el.style.backgroundColor ? rgb2hex(el.style.backgroundColor) : "#f206f9"
-		},
-		disableInput (editorEl) {
-			const markColorInputEl = editorEl.querySelector(`*[data-prop="mark-color"]`)
-			markColorInputEl.disabled = true
-			markColorInputEl.value = "#000000"
-		},
-		setupInput (editorEl, contentEl) {
-			const markColorInputEl = editorEl.querySelector(`*[data-prop="mark-color"]`)
-			markColorInputEl.addEventListener("change", event => {
-				const markEl = contentEl.querySelector(marks.mark.selector + ".selected")
-				if (markEl) markEl.style.backgroundColor = markColorInputEl.value
-			}, false)
-		},
-	},
-	img: {
-		selector: blocks.img.selector,
-		updateInput (el, editorEl) {
-			setAuxiliaryToolbar(editorEl, "img")
-
-			const imgFileEl = editorEl.querySelector(`*[data-prop="img-file"]`)
-			imgFileEl.disabled = false
-			// XXX: No se puede cambiar el texto, ¡esto puede ser confuso!
-
-			const imgAltEl = editorEl.querySelector(`*[data-prop="img-alt"]`)
-			imgAltEl.disabled = false
-			imgAltEl.value = el.alt
-		},
-		disableInput (editorEl) {
-			const imgFileEl = editorEl.querySelector(`*[data-prop="img-file"]`)
-			imgFileEl.disabled = true
-
-			const imgAltEl = editorEl.querySelector(`*[data-prop="img-alt"]`)
-			imgAltEl.disabled = true
-			imgAltEl.value = ""
-		},
-		setupInput (editorEl, contentEl) {
-			const imgFileEl = editorEl.querySelector(`*[data-prop="img-file"]`)
-			imgFileEl.addEventListener("input", event => {
-				const imgEl = contentEl.querySelector("img.selected")
-				if (!imgEl) return
-
-				const file = imgFileEl.files[0]
-
-				imgEl.src = URL.createObjectURL(file)
-				imgEl.dataset.editorLoading = true
-				uploadFile(file)
-					.then(url => {
-						imgEl.src = url
-						delete imgEl.dataset.editorError
-					})
-					.catch(err => {
-						// TODO: mostrar error
-						console.error(err)
-						imgEl.dataset.editorError = true
-					})
-					.finally(() => {
-						delete imgEl.dataset.editorLoading
-					})
-			}, false)
-
-			const imgAltEl = editorEl.querySelector(`*[data-prop="img-alt"]`)
-			imgAltEl.addEventListener("input", event => {
-				const imgEl = contentEl.querySelector("img.selected")
-				if (imgEl) imgEl.alt = imgAltEl.value
-			}, false)
-		},
-	},
-	figure: {
-		selector: blocks.figure.selector,
-		actualInput (el) {
-			// TODO: Cuando tengamos otros iframes hay que seleccionarlos de
-			// otra forma.
-			const tag = el.children[0].tagName.toLowerCase()
-
-			return typesWithProperties[(tag === 'iframe' ? 'pdf' : tag)]
-		},
-		updateInput (el, editorEl) {
-			typesWithProperties.figure.actualInput(el).updateInput(el.children[0], editorEl)
-		},
-		disableInput (editorEl) {},
-		setupInput (editorEl, contentEl) {},
-	},
-	audio: {
-		selector: blocks.audio.selector,
-		updateInput (el, editorEl) {
-			setAuxiliaryToolbar(editorEl, "audio")
-
-			const audioFileEl = editorEl.querySelector(`*[data-prop="audio-file"]`)
-			audioFileEl.disabled = false
-			// XXX: No se puede cambiar el texto, ¡esto puede ser confuso!
-		},
-		disableInput (editorEl) {
-			const audioFileEl = editorEl.querySelector(`*[data-prop="audio-file"]`)
-			audioFileEl.disabled = true
-		},
-		setupInput (editorEl, contentEl) {
-			const audioFileEl = editorEl.querySelector(`*[data-prop="audio-file"]`)
-			audioFileEl.addEventListener("input", event => {
-				const figureEl = getSelected(contentEl)
-				if (!figureEl) return
-
-				const file = audioFileEl.files[0]
-
-				const audioEl = figureEl.querySelector('audio')
-
-				audioEl.src = URL.createObjectURL(file)
-				audioEl.dataset.editorLoading = true
-				uploadFile(file)
-					.then(url => {
-						audioEl.src = url
-						delete audioEl.dataset.editorError
-					})
-					.catch(err => {
-						// TODO: mostrar error
-						console.error(err)
-						audioEl.dataset.editorError = true
-					})
-					.finally(() => {
-						delete audioEl.dataset.editorLoading
-					})
-			}, false)
-		},
-	},
-	video: {
-		selector: blocks.video.selector,
-		updateInput (el, editorEl) {
-			setAuxiliaryToolbar(editorEl, "video")
-
-			const videoFileEl = editorEl.querySelector(`*[data-prop="video-file"]`)
-			videoFileEl.disabled = false
-			// XXX: No se puede cambiar el texto, ¡esto puede ser confuso!
-		},
-		disableInput (editorEl) {
-			const videoFileEl = editorEl.querySelector(`*[data-prop="video-file"]`)
-			videoFileEl.disabled = true
-		},
-		setupInput (editorEl, contentEl) {
-			const videoFileEl = editorEl.querySelector(`*[data-prop="video-file"]`)
-			videoFileEl.addEventListener("input", event => {
-				const videoEl = getSelected(contentEl)
-				if (!videoEl) return
-
-				const file = videoFileEl.files[0]
-
-				videoEl.poster = ""
-				videoEl.src = URL.createObjectURL(file)
-				videoEl.dataset.editorLoading = true
-				uploadFile(file)
-					.then(url => {
-						videoEl.src = url
-						delete videoEl.dataset.editorError
-					})
-					.catch(err => {
-						// TODO: mostrar error
-						console.error(err)
-						videoEl.dataset.editorError = true
-					})
-					.finally(() => {
-						delete videoEl.dataset.editorLoading
-					})
-			}, false)
-		},
-	},
-	pdf: {
-		selector: blocks.pdf.selector,
-		updateInput (el, editorEl) {
-			setAuxiliaryToolbar(editorEl, "pdf")
-
-			const pdfFileEl = editorEl.querySelector(`*[data-prop="pdf-file"]`)
-			pdfFileEl.disabled = false
-			// XXX: No se puede cambiar el texto, ¡esto puede ser confuso!
-		},
-		disableInput (editorEl) {
-			const pdfFileEl = editorEl.querySelector(`*[data-prop="pdf-file"]`)
-			pdfFileEl.disabled = true
-		},
-		setupInput (editorEl, contentEl) {
-			const pdfFileEl = editorEl.querySelector(`*[data-prop="pdf-file"]`)
-			pdfFileEl.addEventListener("input", event => {
-				const figureEl = getSelected(contentEl)
-				if (!figureEl) return
-
-				const file = pdfFileEl.files[0]
-				const pdfEl = figureEl.children[0]
-
-				pdfEl.src = URL.createObjectURL(file)
-				pdfEl.dataset.editorLoading = true
-				uploadFile(file)
-					.then(url => {
-						pdfEl.src = url
-						delete pdfEl.dataset.editorError
-					})
-					.catch(err => {
-						// TODO: mostrar error
-						console.error(err)
-						pdfEl.dataset.editorError = true
-					})
-					.finally(() => {
-						delete pdfEl.dataset.editorLoading
-					})
-			}, false)
-		},
-	},
-}

app/assets/javascripts/02-editor.js

@@ -1,551 +0,0 @@
-const origin = location.origin
-
-/*
- * Guarda una copia local de los cambios para poder recuperarlos
- * después.
- *
- * Usamos la URL completa sin anchors.
- */
-const storageKey = (editorEl) => editorEl.querySelector('[data-target="storage-key"]').value
-
-const forgetContent = (storedKey) => window.localStorage.removeItem(storedKey)
-
-const storeContent = (editorEl, contentEl) => {
-	if (contentEl.innerText.trim().length === 0) return
-
-	window.localStorage.setItem(storageKey(editorEl), contentEl.innerHTML)
-}
-
-const restoreContent = (editorEl, contentEl) => {
-	const content = window.localStorage.getItem(storageKey(editorEl))
-
-	if (!content) return
-	if (content.trim().length === 0) return
-
-	contentEl.innerHTML = content
-}
-
-function uploadFile (file) {
-	return new Promise((resolve, reject) => {
-		const upload = new ActiveStorage.DirectUpload(
-			file,
-			origin + '/rails/active_storage/direct_uploads',
-		)
-
-		upload.create((error, blob) => {
-			if (error) {
-				reject(error)
-			} else {
-				const url = `${origin}/rails/active_storage/blobs/${blob.signed_id}/${blob.filename}`
-				resolve(url)
-			}
-		})
-	})
-}
-
-function moveChildren (from, to, toRef) {
-	while (from.firstChild) to.insertBefore(from.firstChild, toRef);
-}
-
-function isDirectChild (node, supposedChild) {
-	for (const child of node.childNodes) {
-		if (child == supposedChild) return true
-	}
-}
-
-function isChildSelection (sel, el) {
-	return (
-		(el.contains(sel.anchorNode) || el.contains(sel.focusNode))
-		&& !(sel.anchorNode == el || sel.focusNode == el)
-	)
-}
-
-function getElementParent (node) {
-	let parentEl = node
-	while (parentEl.nodeType != Node.ELEMENT_NODE) parentEl = parentEl.parentElement
-	return parentEl
-}
-
-function splitNode (node, range) {
-	const [left, right] = [
-		{ range: document.createRange(), node: node.cloneNode(false) },
-		{ range: document.createRange(), node: node.cloneNode(false) },
-	]
-
-	left.range.setStartBefore(node.firstChild)
-	left.range.setEnd(range.startContainer, range.startOffset)
-	left.range.surroundContents(left.node)
-
-	right.range.setStart(range.endContainer, range.endOffset)
-	right.range.setEndAfter(node.lastChild)
-	right.range.surroundContents(right.node)
-
-	//left.node.appendChild(left.range.extractContents())
-	//left.range.insertNode(left.node)
-
-	//right.node.appendChild(right.range.extractContents())
-	//right.range.insertNode(right.node)
-
-	moveChildren(node, node.parentNode, node)
-	node.parentNode.removeChild(node)
-
-	return [left, right]
-}
-
-/* Configura un botón que hace una acción inline (ej: negrita).
- * Parametros:
- *  * button:		el botón
- *  * mark:			un objeto que representa el tipo de acción (ver types.js)
- *  * contentEl:	el elemento de contenido del editor.
- */
-function setupMarkButton (button, mark, contentEl) {
-	button.addEventListener("click", event => {
-		event.preventDefault()
-
-		const sel = window.getSelection()
-		if (!isChildSelection(sel, contentEl)) return
-
-		let parentEl = getElementParent(sel.anchorNode)
-		//if (sel.anchorNode == parentEl) parentEl = parentEl.firstChild
-
-		const range = sel.getRangeAt(0)
-
-		if (parentEl.matches(mark.selector)) {
-			const [left, right] = splitNode(parentEl, range)
-			right.range.insertNode(range.extractContents())
-
-			const selectionRange = document.createRange()
-			selectionRange.setStartAfter(left.node)
-			selectionRange.setEndBefore(right.node)
-			sel.removeAllRanges()
-			sel.addRange(selectionRange)
-		} else {
-			for (const child of parentEl.childNodes) {
-				if (
-					(child instanceof Element)
-						&& child.matches(mark.selector)
-						&& sel.containsNode(child)
-				) {
-					moveChildren(child, parentEl, child)
-					parentEl.removeChild(child)
-					// TODO: agregar a selección
-					return
-				}
-			}
-
-			const tagEl = mark.createFn()
-
-			try {
-				range.surroundContents(tagEl)
-			} catch (error) {
-				// TODO: mostrar error
-				return console.error("No puedo marcar cosas a través de distintos bloques!")
-			}
-
-			for (const child of tagEl.childNodes) {
-				if (child instanceof Element && child.matches(mark.selector)) {
-					moveChildren(child, tagEl, child)
-					tagEl.removeChild(child)
-				}
-			}
-
-			range.insertNode(tagEl)
-			range.selectNode(tagEl)
-		}
-	})
-}
-
-/* Igual que `setupMarkButton` pero para bloques. */
-function setupBlockButton (button, block, contentEl, editorEl) {
-	button.addEventListener("click", event => {
-		event.preventDefault()
-
-		const sel = window.getSelection()
-		// TODO: mostrar error
-		if (
-			!contentEl.contains(sel.anchorNode)
-			|| !contentEl.contains(sel.focusNode)
-			|| sel.anchorNode == contentEl
-			|| sel.focusNode == contentEl
-		) return
-
-		const range = sel.getRangeAt(0)
-
-		let parentEl = sel.anchorNode
-		while (!isDirectChild(contentEl, parentEl)) parentEl = parentEl.parentElement
-
-		if (block.setFn) {
-			if (parentEl.matches(block.selector)) {
-				tagNameSetFn("P")(parentEl)
-			} else {
-				block.setFn(parentEl)
-			}
-		} else if (block.createFn) {
-			const newEl = block.createFn(editorEl)
-			parentEl.parentElement.insertBefore(newEl, parentEl.nextSibling)
-
-			newEl.click()
-		}
-	})
-}
-
-/* Igual que `setupBlockButton` pero para bloques parientes. */
-function setupParentBlockButton (button, parentBlock, contentEl) {
-	button.addEventListener("click", event => {
-		event.preventDefault()
-
-		const sel = window.getSelection()
-		if (
-			!contentEl.contains(sel.anchorNode)
-			|| !contentEl.contains(sel.focusNode)
-			|| sel.anchorNode == contentEl
-			|| sel.focusNode == contentEl
-		) return
-
-		const range = sel.getRangeAt(0)
-
-		let parentEl = sel.anchorNode
-		while (!isDirectChild(contentEl, parentEl)) parentEl = parentEl.parentElement
-
-		if (parentEl.matches(parentBlock.selector)) {
-			moveChildren(parentEl, parentEl.parentElement, parentEl)
-			parentEl.parentElement.removeChild(parentEl)
-		} else if (elementIsParentBlock(parentEl)) {
-			const el = parentBlock.createFn()
-			moveChildren(parentEl, el, null)
-			parentEl.parentElement.insertBefore(el, parentEl)
-			parentEl.parentElement.removeChild(parentEl)
-		} else {
-			const el = parentBlock.createFn()
-			parentEl.parentElement.insertBefore(el, parentEl)
-			el.appendChild(parentEl)
-		}
-	})
-}
-
-const elementIsTypes = types => element => {
-	for (const type of Object.values(types)) {
-		if (element.matches(type.selector)) return true
-	}
-	return false
-}
-const elementIsBlock = elementIsTypes(blocks)
-const elementIsParentBlock = elementIsTypes(parentBlocks)
-
-function hasContent (element) {
-	if (element.firstElementChild) return true
-	for (const child of element.childNodes) {
-		if (child.nodeType === Node.TEXT_NODE && child.data.length > 0) return true
-		else if (child.hasChildNodes() && hasContent(child)) return true
-	}
-	// TODO: verificar que los elementos tiene contenido
-	if (element.tagName === "IMG"
-		|| element.tagName === "AUDIO"
-		|| element.tagName === "VIDEO"
-		|| element.tagName === "IFRAME") return true
-	return false
-}
-
-/* Limpia el elemento de contenido del editor
- * Por ahora:
- *  * Cambia el tag de los bloques no reconocidos (ver `elementIsBlock`)
- *  * Hace lo que hace cleanNode
- */
-function cleanContent (contentEl) {
-	const sel = window.getSelection()
-
-	cleanNode(contentEl, contentEl)
-
-	for (const child of contentEl.childNodes) {
-		if (child.tagName) {
-			if (elementIsParentBlock(child)) {
-				cleanContent(child)
-			} else if (!elementIsBlock(child)) {
-				child.tagName = "P"
-			}
-		} else if (child.nodeType === Node.TEXT_NODE) {
-			const wasSelected = sel.getRangeAt(0).intersectsNode(child)
-
-			const el = document.createElement("p")
-			el.appendChild(child)
-			contentEl.insertBefore(el, child.nextSibling)
-
-			if (wasSelected) sel.collapse(el, child.data.length)
-		}
-	}
-}
-
-/* Arregla cosas en el elemento de contendo del editor
- * Por ahora:
- *  * Crea un p y inserta la selección si no hay elementos
- *  * Wrappea el contenido de un UL o OL en un LI si no lo está
- */
-function fixContent (contentEl) {
-	for (const child of contentEl.childNodes) {
-		if (child.tagName) {
-			if (elementIsParentBlock(child)) {
-				fixContent(child)
-			} else if (child.tagName === "UL" || child.tagName === "OL") {
-				let notItems = []
-				for (const item of child.childNodes) {
-					if (item.tagName !== "LI") notItems.push(item)
-				}
-
-				if (notItems.length) {
-					const item = document.createElement("li")
-					item.append(...notItems)
-					child.appendChild(item)
-				}
-			}
-		}
-	}
-}
-
-/* Recursivamente "limpia" los nodos a partir del llamado.
- * Por ahora:
- *  * Junta nodos de texto que están al lado
- *  * Junta nodos de la misma "mark" que están al lado
- *  * Borra elementos sin contenido (ver `hasContent`) y no están seleccionados
- *  * Borra inline styles no autorizados
- *  * Borra propiedades de IMG no autorizadas
- *  * Borra <FONT> y <STYLE>
- */
-function cleanNode (node, contentEl) {
-	for (const child of node.childNodes) {
-		if (child.nodeType === Node.TEXT_NODE) {
-			if (child.nextSibling && child.nextSibling.nodeType === Node.TEXT_NODE) {
-				// Juntar nodos
-				child.data += child.nextSibling.data
-				child.parentNode.removeChild(child.nextSibling)
-			}
-		} else if (child.nodeType === Node.ELEMENT_NODE) {
-			if (!hasContent(child) && !window.getSelection().getRangeAt(0).intersectsNode(child))
-				child.parentNode.removeChild(child)
-
-			for (const mark of Object.values(marks)) {
-				if (
-					child.matches(mark.selector)
-						&& child.nextSibling
-						&& (child.nextSibling instanceof Element)
-						&& child.nextSibling.matches(mark.selector)
-				) {
-					moveChildren(child.nextSibling, child, null)
-					child.nextSibling.parentNode.removeChild(child.nextSibling)
-				}
-			}
-
-			if (child.tagName === "LI") {
-				let parentEl = child
-				while (
-					parentEl
-					&& !(parentEl.nodeType == Node.ELEMENT_NODE && elementIsBlock(parentEl))
-					&& contentEl.contains(parentEl)
-				)
-					parentEl = parentEl.parentElement
-
-				if (
-					parentEl
-					&& contentEl.contains(parentEl)
-					&& parentEl.tagName !== "UL"
-					&& parentEl.tagName !== "OL"
-				)
-					moveChildren(child, parentEl, child.nextSibling)
-			} else if (child.tagName === "IMG") {
-				if (child.getAttribute("width")) child.removeAttribute("width")
-				if (child.getAttribute("height")) child.removeAttribute("height")
-				if (child.getAttribute("vspace")) child.removeAttribute("vspace")
-				if (child.getAttribute("hspace")) child.removeAttribute("hspace")
-				if (child.align.length) child.removeAttribute("align")
-				if (child.name.length) child.removeAttribute("name")
-				if (!child.src.length) child.src = "/placeholder.png"
-			} else if (child.tagName === "FONT") {
-				moveChildren(child, child.parentElement, child.nextSiling)
-				child.parentElement.removeChild(child)
-				return
-			} else if (child.tagName === "STYLE") {
-				return child.parentElement.removeChild(child)
-			} else if (child.tagName === "B") {
-				const el = document.createElement("STRONG")
-				moveChildren(child, el)
-				child.parentElement.insertBefore(el, child)
-				child.parentElement.removeChild(child)
-			} else if (child.tagName === "I") {
-				const el = document.createElement("EM")
-				moveChildren(child, el)
-				child.parentElement.insertBefore(el, child)
-				child.parentElement.removeChild(child)
-			}
-
-			for (const style of Object.values(child.style)) {
-				const value = child.style[style]
-
-				switch (style) {
-				case 'background-color':
-					if (child.tagName === "MARK") break
-				default:
-					child.style[style] = ""
-				}
-			}
-		}
-		cleanNode(child, contentEl)
-	}
-}
-
-/* Generar el clickListener para este editor.
- */
-function generateClickListener (editorEl, contentEl) {
-	/* El event listener para los typesWithProperties.
-	 */
-	return function clickListener (event) {
-		// Borrar todas las selecciones
-		for (const el of contentEl.querySelectorAll(".selected")) {
-			el.classList.remove("selected")
-		}
-
-		setAuxiliaryToolbar(editorEl)
-
-		let selectedType
-		let selectedEl
-
-		for (const [name, type] of Object.entries(typesWithProperties)) {
-			type.disableInput(editorEl)
-
-			let el = event.target
-			while (el && !el.matches(type.selector)) el = el.parentElement
-			if (el && contentEl.contains(el)) {
-				selectedType = type
-				selectedEl = el
-			}
-		}
-
-		if (selectedType) {
-			event.preventDefault()
-			selectedType.updateInput(selectedEl, editorEl)
-			event.target.classList.add("selected")
-			return false
-		}
-	}
-}
-
-function setupEditor (editorEl) {
-	// XXX: ¡Esto afecta a todo el documento! ¿Quizás usar un iframe para el editor?
-	document.execCommand('defaultParagraphSeparator', false, 'p')
-
-	const contentEl = editorEl.querySelector(".editor-content")
-
-	contentEl.addEventListener("keydown", event => {
-		if (event.keyCode === 32) { // Espacio
-			event.preventDefault()
-			const sel = window.getSelection()
-			const range = sel.getRangeAt(0)
-			range.insertNode(document.createTextNode("\xa0"))
-			cleanContent(contentEl)
-			range.collapse()
-		}
-	})
-	contentEl.addEventListener("paste", event => {
-		contentEl.querySelector("editor-aviso-word").style.display = "block"
-	})
-	document.addEventListener("selectionchange", event => {
-		cleanContent(contentEl)
-	})
-
-	const clickListener = generateClickListener(editorEl, contentEl)
-	contentEl.addEventListener("click", clickListener, true)
-
-	const htmlEl = editorEl.querySelector("textarea")
-	const observer = new MutationObserver((mutationList, observer) => {
-		cleanContent(contentEl)
-		fixContent(contentEl)
-		storeContent(editorEl, contentEl)
-
-		htmlEl.value = contentEl.innerHTML
-	})
-	observer.observe(contentEl, {
-		childList: true,
-		attributes: true,
-		subtree: true,
-		characterData: true,
-	})
-
-	const editorBtn = id => editorEl.querySelector(`*[data-button="${id}"]`)
-
-	// XXX: Por qué está duplicada de types.js esta función?
-	const tagNameSetFn = tagName => el => {
-		const newEl = document.createElement(tagName)
-		moveChildren(el, newEl, null)
-		el.parentNode.insertBefore(newEl, el)
-		el.parentNode.removeChild(el)
-		window.getSelection().collapse(newEl, 0)
-	}
-
-	// == SETUP BUTTONS ==
-	for (const [name, mark] of Object.entries(marks)) {
-		setupMarkButton(editorBtn(name), mark, contentEl)
-	}
-
-	for (const [name, block] of Object.entries(blocks)) {
-		if (block.noButton) continue
-		setupBlockButton(editorBtn(name), block, contentEl, editorEl)
-	}
-
-	for (const [name, parentBlock] of Object.entries(parentBlocks)) {
-		if (parentBlock.noButton) continue
-		setupParentBlockButton(editorBtn(name), parentBlock, contentEl)
-	}
-
-	for (const [name, type] of Object.entries(typesWithProperties)) {
-		type.setupInput(editorEl, contentEl)
-	}
-
-	document.addEventListener(editorBtn("mark"), () => setAuxiliaryToolbar(editorEl, "mark"))
-	document.addEventListener(editorBtn("img"), () => setAuxiliaryToolbar(editorEl, "img"))
-	document.addEventListener(editorBtn("audio"), () => setAuxiliaryToolbar(editorEl, "audio"))
-	document.addEventListener(editorBtn("video"), () => setAuxiliaryToolbar(editorEl, "video"))
-	document.addEventListener(editorBtn("pdf"), () => setAuxiliaryToolbar(editorEl, "pdf"))
-	document.addEventListener(editorBtn("a"), () => setAuxiliaryToolbar(editorEl, "a"))
-
-	for (const video of document.querySelectorAll('.editor .editor-content video')) {
-		video.addEventListener('click', event => event.target.controls = true)
-		video.addEventListener('focusout', event => event.target.controls = false)
-		video.controls = false
-	}
-
-	cleanContent(contentEl)
-	fixContent(contentEl)
-
-	// Recuperar el contenido si hay algo guardado, si tuviéramos un campo
-	// de última edición podríamos saber si el artículo fue editado
-	// después o la versión local es la última.
-	//
-	// TODO: Preguntar si se lo quiere recuperar.
-	restoreContent(editorEl, contentEl)
-
-	htmlEl.value = contentEl.innerHTML
-}
-
-// TODO: por ahora confiamos, quizás queremos filtrar estilos?
-function stringifyAllowedStyle (element) {
-	return element.style.cssText
-}
-
-document.addEventListener("turbolinks:load", () => {
-	for (const editorEl of document.querySelectorAll(".editor")) {
-		if (!editorEl.querySelector('.editor-toolbar')) continue
-
-		setupEditor(editorEl)
-	}
-
-	const flash = document.querySelector('.js-flash[data-target="editor"]')
-	if (!flash) return
-
-	switch (flash.dataset.action) {
-		case 'forget-content':
-			if (!flash.dataset.keys) break
-
-			try { JSON.parse(flash.dataset.keys).forEach(forgetContent) } catch(e) { undefined }
-
-			break
-		default:
-	}
-})

app/assets/javascripts/application.js

@@ -1,5 +0,0 @@
-//= require rails-ujs
-//= require turbolinks
-//= require input-tag/input-tag.js
-//= require input-map/input-map.js
-//= require_tree .

app/assets/javascripts/image_preview.js

@@ -1,11 +0,0 @@
-document.addEventListener('turbolinks:load', () => {
-  document.querySelectorAll('input[type=file]').forEach(file => {
-    if (!file.dataset.preview) return
-
-    file.addEventListener('change', event => {
-      if (file.files.length === 0) return
-
-      document.querySelector('#' + file.dataset.preview).src = window.URL.createObjectURL(file.files[0])
-    })
-  })
-})

app/assets/javascripts/turbolinks-anchors.js

@@ -1,3 +0,0 @@
-document.addEventListener('turbolinks:load', () => {
-  document.querySelectorAll('a[href^="#"]').forEach(a => a.data.turbolinks = false)
-})

app/assets/stylesheets/application.scss

@@ -13,16 +13,41 @@ $colors: (
 
 // Redefinir variables de Bootstrap
 $primary: $magenta;
+$secondary: $black;
 $jumbotron-bg: transparent;
 $enable-rounded: false;
-$form-feedback-valid-color: $cyan;
+$form-feedback-valid-color: $black;
 $form-feedback-invalid-color: $magenta;
 $form-feedback-icon-valid-color: $black;
 $component-active-bg: $magenta;
 
+$spacers: (
+  2-plus: 0.75rem
+);
+
+$sizes: (
+  "70ch": 70ch,
+);
+
 @import "bootstrap";
 @import "editor";
 
+@each $color, $rgb in $theme-colors {
+  .#{$color} {
+    color: var(--#{$color});
+
+    &:focus {
+      color: var(--#{$color});
+    }
+
+    ::-moz-selection,
+    ::selection {
+      background: var(--#{$color});
+      color: white;
+    }
+  }
+}
+
 .editor {
   .editor-content {
     figure {
@@ -43,6 +68,25 @@ $component-active-bg: $magenta;
     --background: #{$black};
     --color: #{$cyan};
   }
+
+  .btn-secondary {
+    background-color: $white;
+    color: $black;
+    border: none;
+
+    &:hover {
+      color: $black;
+      background-color: $cyan;
+    }
+
+    &:active {
+      background-color: $cyan;
+    }
+
+    &:focus {
+      box-shadow: 0 0 0 0.2rem $cyan;
+    }
+  }
 }
 
 // TODO: Encontrar la forma de generar esto desde los locales de Rails
@@ -121,6 +165,7 @@ ol.breadcrumb {
   color: var(--foreground);
 }
 
+.table tr.sticky-top,
 .form-control,
 .custom-file-label {
   background-color: var(--background);
@@ -148,6 +193,12 @@ ol.breadcrumb {
   transition: all 3s;
 }
 
+fieldset {
+  legend {
+    font-size: 1rem;
+  }
+}
+
 .mapable,
 .taggable {
   .input-map,
@@ -174,7 +225,7 @@ ol.breadcrumb {
 
       &[type=button] {
         @extend .btn;
-        @extend .btn-info;
+        @extend .btn-secondary;
         @extend .m-0;
       }
     }
@@ -188,10 +239,6 @@ svg {
 }
 
 .btn {
-  background-color: var(--foreground);
-  color: var(--background);
-  border: none;
-  border-radius: 0;
   margin-right: 0.3rem;
   margin-bottom: 0.3rem;
 
@@ -209,6 +256,10 @@ svg {
   }
 }
 
+.btn-sm {
+  @extend .badge
+}
+
 .black-bg {
   color: $white;
   background-color: $black;
@@ -223,7 +274,7 @@ svg {
     color: $magenta;
   }
 
-  .btn {
+  .btn-secondary {
     background-color: $white;
     color: $black;
     border: none;
@@ -354,8 +405,18 @@ $bezier: cubic-bezier(0.75, 0, 0.25, 1);
   .text-column-#{$size} {
     column-count: $size;
   }
+
+  .line-clamp-#{$size} {
+    overflow: hidden;
+    display: -webkit-box;
+    -webkit-line-clamp: $size;
+    -webkit-box-orient: vertical;
+  }
 }
 
+.word-break-all { word-break: break-all !important; }
+.hyphens { hyphens: auto; }
+
 /*
  * Modificadores de Bootstrap que no tienen versión responsive.
  */
@@ -378,6 +439,8 @@ $bezier: cubic-bezier(0.75, 0, 0.25, 1);
     .text-#{$grid-breakpoint}-right  { text-align: right !important; }
     .text-#{$grid-breakpoint}-center { text-align: center !important; }
 
+    .word-break-#{$grid-breakpoint}-all { word-break: break-all !important; }
+
     // posición
     @each $position in $positions {
       .position-#{$grid-breakpoint}-#{$position} { position: $position !important; }
@@ -387,6 +450,8 @@ $bezier: cubic-bezier(0.75, 0, 0.25, 1);
     @each $prop, $abbrev in (width: w, height: h) {
       @each $size, $length in $sizes {
         .#{$abbrev}-#{$grid-breakpoint}-#{$size} { #{$prop}: $length !important; }
+        .min-#{$abbrev}-#{$grid-breakpoint}-#{$size} { min-#{$prop}: $length !important; }
+        .max-#{$abbrev}-#{$grid-breakpoint}-#{$size} { max-#{$prop}: $length !important; }
       }
     }
 
@@ -488,3 +553,71 @@ $bezier: cubic-bezier(0.75, 0, 0.25, 1);
     }
   }
 }
+
+@import "new_editor";
+
+.new-editor {
+  .editor {
+    table {
+      @extend .table;
+      @extend .table-responsive;
+    }
+  }
+}
+
+.content {
+  p { min-height: $font-size-base * $line-height-base; }
+  h1 { min-height: $h1-font-size * $headings-line-height; }
+  h2 { min-height: $h2-font-size * $headings-line-height; }
+  h3 { min-height: $h3-font-size * $headings-line-height; }
+  h4 { min-height: $h4-font-size * $headings-line-height; }
+  h5 { min-height: $h5-font-size * $headings-line-height; }
+  h6 { min-height: $h6-font-size * $headings-line-height; }
+
+  iframe { border: 0; }
+
+  audio { width: 100%; }
+
+  img,
+  video,
+  iframe {
+    @extend .img-fluid;
+    height: auto;
+  }
+
+  & > * {
+    margin-bottom: 1rem;
+
+    &:last-child {
+      margin-bottom: 0;
+    }
+  }
+}
+// details styles
+
+.details {
+	& > summary {
+		list-style: none;
+		cursor: pointer;
+
+    .hide-when-open {
+      display: inline;
+    }
+
+    .show-when-open {
+      display: none;
+    }
+  }
+
+  &[open] {
+		& > summary {
+      .hide-when-open {
+        display: none;
+      }
+
+      .show-when-open {
+        display: inline;
+      }
+		}
+	}
+}

app/assets/stylesheets/dark.scss

@@ -0,0 +1,34 @@
+$black: black;
+$white: white;
+$cyan: #13fefe;
+
+:root {
+  --foreground: #{$white};
+  --background: #{$black};
+  --color: #{$cyan};
+}
+
+.btn {
+  background-color: $white;
+}
+
+.btn-secondary {
+  background-color: $white;
+  color: $black;
+  border: none;
+
+  &:hover {
+    color: $black;
+    background-color: $cyan;
+  }
+
+  &:active {
+    background-color: $cyan;
+  }
+
+  &:focus {
+    box-shadow: 0 0 0 0.2rem $cyan;
+  }
+}
+
+

app/assets/stylesheets/editor.scss

@@ -1,7 +1,14 @@
-.editor {
+.old.editor {
 	box-sizing: border-box;
 	*, *::before, *::after { box-sizing: inherit; }
 
+	// Arreglo temporal para que las cosas sean legibles en modo oscuro
+	--foreground: black;
+	--background: white;
+	--color: #f206f9;
+	background: var(--background);
+	color: var(--foreground);
+
 	h1, h2, h3, h4, h5, h6, p, li {
 		min-height: 1.5rem;
 	}
@@ -11,8 +18,6 @@
 		padding: 0;
 	}
 
-	.selected { outline: #f206f9 solid medium; }
-
 	iframe {
 		border: 0;
 		min-height: 480px;
@@ -35,7 +40,10 @@
 		background: white;
 	}
 
-	.editor-aviso-word { display: none; }
+	.editor-aviso-word {
+		display: none;
+		position: initial; /* evitar que tape el texto */
+	}
 
 	.editor-primary-toolbar, .editor-auxiliary-toolbar {
 		display: block;
@@ -47,7 +55,7 @@
 		& > * {
 			display: none;
 		}
-		.editor-auxiliary-tool-active {
+		[data-editor-auxiliary-active] {
 			display: block;
 		}
 	}
@@ -57,9 +65,21 @@
 	div[data-align="center"] { text-align: center; }
 	div[data-align="right"] { text-align: right; }
 
-  .editor-content {
-    min-height: 480px;
-  }
+	.editor-content {
+		min-height: 480px;
+		p, h1, h2, h3, h4, h5, h6, ul, li, blockquote, figcaption { outline: #ccc solid thin; }
+		blockquote {
+			border-left: #555 solid .25em;
+			padding: .75em;
+		}
+		strong, em, del, u, sub, sup, small { background: #0002; }
+		a { background: #13fefe50; }
+		[data-editor-selected] { outline: #f206f9 solid thick; }
+		p[data-multimedia-inner] {
+			// Ignorar clicks en el párrafo placeholder
+			pointer-events: none;
+		}
+	}
 
 	*[data-editor-loading] {
 		opacity: 0.5;

app/assets/stylesheets/new_editor.scss

@@ -0,0 +1,22 @@
+.new-editor {
+  .editor {
+    .menubar {
+      z-index: 1;
+
+      label.btn {
+        margin-bottom: 0.3rem !important;
+      }
+
+      .btn-group {
+        .btn {
+          margin-right: 0;
+        }
+      }
+    }
+
+    .ProseMirror,
+    & > ol li {
+      margin-bottom: 1rem;
+    }
+  }
+}

app/controllers/active_storage/direct_uploads_controller_decorator.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module ActiveStorage
+  # Modifica la creación de un blob antes de subir el archivo para que
+  # incluya el JekyllService adecuado.
+  module DirectUploadsControllerDecorator
+    extend ActiveSupport::Concern
+
+    included do
+      def create
+        blob = ActiveStorage::Blob.create_before_direct_upload!(service_name: session[:service_name], **blob_args)
+        render json: direct_upload_json(blob)
+      end
+
+      private
+
+      # Normalizar los caracteres unicode en los nombres de archivos
+      # para que puedan propagarse correctamente a través de todo el
+      # stack.
+      def blob_args
+        params.require(:blob).permit(:filename, :byte_size, :checksum, :content_type,
+                                     metadata: {}).to_h.symbolize_keys.tap do |ba|
+          ba[:filename] = ba[:filename].unicode_normalize.sub(/\A_+/, '')
+        end
+      end
+    end
+  end
+end
+
+ActiveStorage::DirectUploadsController.include ActiveStorage::DirectUploadsControllerDecorator

app/controllers/active_storage/disk_controller_decorator.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module ActiveStorage
+  # Modificar {DiskController} para poder asociar el blob a un sitio
+  module DiskControllerDecorator
+    extend ActiveSupport::Concern
+
+    included do
+      alias_method :original_show, :show
+
+      # Permitir incrustar archivos subidos (especialmente PDFs) desde
+      # otros sitios.
+      def show
+        original_show.tap do |s|
+          response.headers.delete 'X-Frame-Options'
+        end
+      end
+
+      rescue_from ActiveRecord::RecordNotFound, with: :page_not_found
+
+      # Asociar el archivo subido al sitio correspondiente.  Cada sitio
+      # tiene su propio servicio de subida de archivos.
+      def update
+        if (token = decode_verified_token)
+          if acceptable_content?(token)
+            blob = ActiveStorage::Blob.find_by_key! token[:key]
+            site = Site.find_by_name token[:service_name]
+
+            if remote_file?(token)
+              begin
+                url = request.body.read
+                body = Down.download(url, max_size: 111.megabytes)
+                checksum = Digest::MD5.file(body.path).base64digest
+                blob.metadata[:url] = url
+                blob.update_columns checksum: checksum, byte_size: body.size, metadata: blob.metadata
+              rescue StandardError => e
+                ExceptionNotifier.notify_exception(e, data: { key: token[:key], url: url, site: site.name })
+
+                head :content_too_large
+              end
+            else
+              body = request.body
+              checksum = token[:checksum]
+            end
+
+            named_disk_service(token[:service_name]).upload token[:key], body, checksum: checksum
+
+            site.static_files.attach(blob)
+          else
+            head :unprocessable_entity
+          end
+        else
+          head :not_found
+        end
+      rescue ActiveStorage::IntegrityError
+        head :unprocessable_entity
+      end
+
+      private
+
+      def remote_file?(token)
+        token[:content_type] == 'sutty/download-from-url'
+      end
+
+      def page_not_found(exception)
+        head :not_found
+        ExceptionNotifier.notify_exception(exception, data: {params: params.to_hash})
+      end
+    end
+  end
+end
+
+ActiveStorage::DiskController.include ActiveStorage::DiskControllerDecorator

app/controllers/activity_pubs_controller.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+# Gestiona acciones de moderación
+class ActivityPubsController < ApplicationController
+  include ModerationConcern
+
+  ActivityPub.events.each do |event|
+    define_method(event) do
+      authorize activity_pub
+
+      if event == :report
+        remote_flag_params(activity_pub).tap do |p|
+          activity_pub.remote_flag_id = p[:remote_flag_attributes][:id]
+          activity_pub.update(p)
+        end
+      end
+
+      message =
+        if activity_pub.public_send(:"may_#{event}?") && activity_pub.public_send(:"#{event}!")
+          :success
+        else
+          :error
+        end
+
+      flash[message] = I18n.t("activity_pubs.#{event}.#{message}")
+
+      redirect_to_moderation_queue!
+    end
+  end
+
+  def action_on_several
+    redirect_to_moderation_queue!
+
+    activity_pubs = site.activity_pubs.where(id: params[:activity_pub])
+
+    return if activity_pubs.count.zero?
+
+    authorize activity_pubs
+
+    action = params[:activity_pub_action].to_sym
+    method = :"#{action}_all!"
+    may    = :"may_#{action}?"
+
+    return unless ActivityPub.events.include? action
+
+    # Crear una sola remote flag por autore
+    ActivityPub.transaction do
+      if action == :report
+        message = remote_flag_params(activity_pubs.first).dig(:remote_flag_attributes, :message)
+
+        activity_pubs.distinct.pluck(:actor_id).each do |actor_id|
+          remote_flag = ActivityPub::RemoteFlag.find_or_initialize_by(actor_id: actor_id, site_id: site.id)
+          remote_flag.message = message
+          # Lo estamos actualizando, con lo que lo vamos a volver a enviar
+          remote_flag.requeue if remote_flag.persisted?
+          remote_flag.save
+          # XXX: Idealmente todas las ActivityPub que enviamos pueden
+          # cambiar de estado, pero chequeamos de todas formas.
+          remote_flag.activity_pubs << (activity_pubs.where(actor_id: actor_id).to_a.select { |a| a.public_send(may) })
+        end
+      end
+
+      message = activity_pubs.public_send(method) ? :success : :error
+
+      flash[message] = I18n.t("activity_pubs.action_on_several.#{message}")
+    end
+  end
+
+  private
+
+  def activity_pub
+    @activity_pub ||= site.activity_pubs.find(params[:activity_pub_id])
+  end
+end

app/controllers/actor_moderations_controller.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+# Gestiona la cola de moderación de actores
+class ActorModerationsController < ApplicationController
+  include ModerationConcern
+  include ModerationFiltersConcern
+
+  before_action :authenticate_usuarie!
+
+  breadcrumb -> { current_usuarie.email }, :edit_usuarie_registration_path
+  breadcrumb 'sites.index', :sites_path, match: :exact
+
+  ActorModeration.events.each do |actor_event|
+    define_method(actor_event) do
+      authorize actor_moderation
+
+      # Crea una RemoteFlag si se envían los parámetros adecuados
+      if actor_event == :report
+        remote_flag_params(actor_moderation).tap do |p|
+          actor_moderation.remote_flag_id = p[:remote_flag_attributes][:id]
+          actor_moderation.update(p)
+        end
+      end
+
+      message =
+        if actor_moderation.public_send(:"may_#{actor_event}?") && actor_moderation.public_send(:"#{actor_event}!")
+          :success
+        else
+          :error
+        end
+
+      flash[message] = I18n.t("actor_moderations.#{actor_event}.#{message}")
+
+      redirect_to_moderation_queue!
+    end
+  end
+
+  # Ver el perfil remoto
+  def show
+    breadcrumb site.title, site_posts_path(site)
+    breadcrumb I18n.t('moderation_queue.index.title'), site_moderation_queue_path(site)
+
+    @remote_profile = actor_moderation.actor.content
+    @moderation_queue = rubanok_process(site.activity_pubs.where(actor_id: actor_moderation.actor_id),
+                                        with: ActivityPubProcessor)
+
+    breadcrumb @remote_profile['name'] || actor_moderation.actor.mention || actor_moderation.actor.uri, ''
+  end
+
+  def action_on_several
+    redirect_to_moderation_queue!
+
+    actor_moderations = site.actor_moderations.where(id: params[:actor_moderation])
+
+    return if actor_moderations.count.zero?
+
+    authorize actor_moderations
+
+    action = params[:actor_moderation_action].to_sym
+    method = :"#{action}_all!"
+    may    = :"may_#{action}?"
+
+    return unless ActorModeration.events.include? action
+
+    ActorModeration.transaction do
+      if action == :report
+        actor_moderations.find_each do |actor_moderation|
+          next unless actor_moderation.public_send(may)
+
+          actor_moderation.update(actor_moderation_params(actor_moderation))
+        end
+      end
+
+      message = actor_moderations.public_send(method) ? :success : :error
+
+      flash[message] = I18n.t("actor_moderations.action_on_several.#{message}")
+    end
+  end
+
+  private
+
+  def actor_moderation
+    @actor_moderation ||= site.actor_moderations.find(params[:actor_moderation_id] || params[:id])
+  end
+end

app/controllers/api/v1/activity_pub/remote_flags_controller.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Api
+  module V1
+    module ActivityPub
+      # Devuelve los reportes remotos hechos
+      #
+      # @todo Verificar la firma. Por ahora no es necesario porque no es
+      # posible obtener remotamente todos los reportes y se identifican por
+      # UUIDv4.
+      class RemoteFlagsController < BaseController
+        skip_forgery_protection
+
+        def show
+          render json: (remote_flag&.content || {}), content_type: 'application/activity+json'
+        end
+
+        private
+
+        # @return [ActivityPub::RemoteFlag,nil]
+        def remote_flag
+          @remote_flag ||= ::ActivityPub::RemoteFlag.find(params[:id])
+        end
+      end
+    end
+  end
+end

app/controllers/api/v1/contact_controller.rb

@@ -18,9 +18,10 @@ module Api
 
         # Si todo salió bien, enviar los correos y redirigir al sitio.
         # El sitio nos dice a dónde tenemos que ir.
-        ContactJob.perform_async site.id,
+        ContactJob.perform_later site,
                                  params[:form],
-                                 contact_params.to_h.symbolize_keys
+                                 contact_params.to_h.symbolize_keys,
+                                 params[:redirect]
 
         redirect_to params[:redirect] || origin.to_s
       end

app/controllers/api/v1/csp_reports_controller.rb

@@ -6,19 +6,22 @@ module Api
     class CspReportsController < BaseController
       skip_forgery_protection
 
+      # No queremos indicar que algo salió mal
+      rescue_from ActionController::ParameterMissing, with: :csp_report_created
+
       # Crea un reporte de CSP intercambiando los guiones medios por
       # bajos
       #
       # TODO: Aplicar rate_limit
       def create
-        csp = CspReport.new(csp_report_params.to_h.map do |k, v|
-                              [k.tr('-', '_'), v]
-                            end.to_h)
+        csp = CspReport.new(csp_report_params.to_h.transform_keys do |k|
+                              k.tr('-', '_')
+                            end)
 
         csp.id = SecureRandom.uuid
         csp.save
 
-        render json: {}, status: :created
+        csp_report_created
       end
 
       private
@@ -39,6 +42,10 @@ module Api
                       :'column-number',
                       :'source-file')
       end
+
+      def csp_report_created
+        render json: {}, status: :created
+      end
     end
   end
 end

app/controllers/api/v1/notices_controller.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Api
+  module V1
+    # Recibe notificaciones desde Airbrake
+    class NoticesController < BaseController
+      skip_before_action :verify_authenticity_token
+
+      # Generar un stacktrace en segundo plano y enviarlo por correo
+      # solo si la API key es verificable.  Del otro lado siempre
+      # respondemos con lo mismo.
+      def create
+        if (site&.airbrake_valid? airbrake_token) && !detected_device.bot?
+          BacktraceJob.perform_later site: site,
+                                     params: airbrake_params.to_h
+        end
+
+        render status: 201, json: { id: 1, url: '' }
+      end
+
+      private
+
+      # XXX: Por alguna razón Airbrake envía los datos con Content-Type:
+      # text/plain.
+      def airbrake_params
+        @airbrake_params ||=
+          params.merge!(FastJsonparser.parse(request.raw_post) || {})
+                .permit(
+                  {
+                    errors: [
+                      :type,
+                      :message,
+                      { backtrace: %i[file line column function] }
+                    ]
+                  },
+                  {
+                    context: [
+                      :url,
+                      :language,
+                      :severity,
+                      :userAgent,
+                      :windowError,
+                      :rootDirectory,
+                      {
+                        history: [
+                          :date,
+                          :type,
+                          :severity,
+                          :target,
+                          :method,
+                          :duration,
+                          :statusCode,
+                          { arguments: [] }
+                        ]
+                      }
+                    ]
+                  }
+                )
+      end
+
+      def site
+        @site ||= Site.find(params[:site_id])
+      rescue ActiveRecord::RecordNotFound
+      end
+
+      def airbrake_token
+        @airbrake_token ||= params[:key]
+      end
+
+      # @return [DeviceDetector]
+      def detected_device
+        @detected_device ||= DeviceDetector.new(request.headers['User-Agent'], request.headers)
+      end
+    end
+  end
+end

app/controllers/api/v1/sites_controller.rb

@@ -9,44 +9,26 @@ module Api
 
       # Lista de nombres de dominios a emitir certificados
       def index
-        render json: sites_names + alternative_names + api_names
-      end
-
-      # Sitios con hidden service de Tor
-      #
-      # @return [Array] lista de nombres de sitios sin onion aun
-      def hidden_services
-        render json: DeployHiddenService.where(values: nil).includes(:site).pluck(:name)
-      end
-
-      # Tor va a enviar el onion junto con el nombre del sitio y tenemos
-      # que guardarlo en su deploy_hidden_service.
-      #
-      # @params [String] name
-      # @params [String] onion
-      def add_onion
-        site = Site.find_by(name: params[:name])
-
-        if site
-          usuarie = GitAuthor.new email: 'tor@' + Site.domain, name: 'Tor'
-          service = SiteService.new site: site, usuarie: usuarie,
-                                    params: params
-          service.add_onion
-        end
-
-        head :ok
+        render json: alternative_names + api_names + www_names
       end
 
       private
 
-      # Nombres de los sitios
-      def sites_names
-        Site.all.order(:name).pluck(:name)
+      def canonicalize(name)
+        name.end_with?('.') ? name[0..-2] : "#{name}.#{Site.domain}"
+      end
+
+      def subdomain?(name)
+        name.end_with? ".#{Site.domain}"
       end
 
       # Dominios alternativos
       def alternative_names
-        DeployAlternativeDomain.all.map(&:hostname)
+        (DeployAlternativeDomain.all.map(&:hostname) + DeployLocalizedDomain.all.map(&:hostname)).map do |name|
+          canonicalize name
+        end.reject do |name|
+          subdomain? name
+        end
       end
 
       # Obtener todos los sitios con API habilitada, es decir formulario
@@ -56,7 +38,18 @@ module Api
       def api_names
         Site.where(contact: true)
             .or(Site.where(colaboracion_anonima: true))
-            .select("'api.' || name as name").map(&:name)
+            .select("'api.' || name as name").map(&:name).map do |name|
+              canonicalize name
+            end.reject do |name|
+              subdomain? name
+            end
+      end
+
+      # Todos los dominios con WWW habilitado
+      def www_names
+        Site.where(id: DeployWww.all.pluck(:site_id)).select("'www.' || name as name").map(&:name).map do |name|
+          canonicalize name
+        end
       end
     end
   end

app/controllers/api/v1/webhooks/concerns/webhook_concern.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module Api
+  module V1
+    module Webhooks
+      module Concerns
+        # Helpers para webhooks
+        module WebhookConcern
+          extend ActiveSupport::Concern
+
+          included do
+            skip_before_action :verify_authenticity_token
+
+            # Responde con forbidden si falla la validación del token
+            rescue_from ActiveRecord::RecordNotFound, with: :platforms_answer
+            rescue_from ActiveRecord::RecordInvalid, with: :platforms_answer
+
+            private
+
+            # Valida el token que envía la plataforma en el webhook
+            #
+            # @return [String]
+            def token
+              @token ||=
+                begin
+                  header  = request.headers
+                  token   = header['X-Social-Inbox'].presence
+                  token ||= header['X-Gitlab-Token'].presence
+                  token ||= token_from_signature(header['X-Gitea-Signature'].presence)
+                  token ||= token_from_signature(header['X-Hub-Signature-256'].presence, 'sha256=')
+                  token
+                ensure
+                  raise ActiveRecord::RecordNotFound, 'Proveedor no soportado' if token.blank?
+                end
+            end
+
+            # Valida token a partir de firma
+            #
+            # @param signature [String,nil]
+            # @param prepend [String]
+            # @return [String, nil]
+            def token_from_signature(signature, prepend = '')
+              return if signature.nil?
+
+              payload = request.raw_post
+
+              site.roles.where(temporal: false, rol: 'usuarie').pluck(:token).find do |token|
+                new_signature = prepend + OpenSSL::HMAC.hexdigest(OpenSSL::Digest.new('sha256'), token, payload)
+
+                ActiveSupport::SecurityUtils.secure_compare(new_signature, signature.to_s)
+              end
+            end
+
+            # Encuentra el sitio a partir de la URL
+            #
+            # @return [Site]
+            def site
+              @site ||= Site.find_by_name!(params[:site_id])
+            end
+
+            # Encuentra le usuarie
+            #
+            # @return [Site]
+            def usuarie
+              @usuarie ||= site.roles.find_by!(temporal: false, rol: 'usuarie', token: token).usuarie
+            end
+
+            # Respuesta de error a plataformas
+            def platforms_answer(exception)
+              ExceptionNotifier.notify_exception(exception, data: { headers: request.headers.to_h })
+
+              head :forbidden
+            end
+          end
+        end
+      end
+    end
+  end
+end

app/controllers/api/v1/webhooks/pull_controller.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Api
+  module V1
+    module Webhooks
+      # Recibe webhooks y lanza un PullJob
+      class PullController < BaseController
+        include Api::V1::Webhooks::Concerns::WebhookConcern
+
+        # Trae los cambios a partir de un post de Webhooks:
+        # (Gitlab, Github, Gitea, etc)
+        #
+        # @return [nil]
+        def pull
+          message = I18n.with_locale(site.default_locale) do
+            I18n.t('webhooks.pull.message')
+          end
+
+          GitPullJob.perform_later(site, usuarie, message)
+          head :ok
+        end
+      end
+    end
+  end
+end

app/controllers/api/v1/webhooks/social_inbox_controller.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Api
+  module V1
+    module Webhooks
+      # Recibe webhooks de la Social Inbox
+      #
+      # @see {https://www.w3.org/TR/activitypub/}
+      class SocialInboxController < BaseController
+        include Api::V1::Webhooks::Concerns::WebhookConcern
+
+        # Validar que el token sea correcto
+        before_action :usuarie
+
+        # Cuando una actividad ingresa en la cola de moderación, la
+        # recibimos por acá
+        #
+        # Vamos a recibir Create, Update, Delete, Follow, Undo,
+        # Announce, Like y obtener el objeto dentro de cada una para
+        # guardar un estado asociado al sitio.
+        #
+        # El objeto del estado puede ser un objeto o une actore,
+        # dependiendo de la actividad.
+        def moderationqueued
+          process! :paused
+
+          head :accepted
+        end
+
+        # Cuando la Social Inbox acepta una actividad, la recibimos
+        # igual y la guardamos por si cambiamos de idea.
+        def onapproved
+          process! :approved
+
+          head :accepted
+        end
+
+        # Cuando la Social Inbox rechaza una actividad, la recibimos
+        # igual y la guardamos por si cambiamos de idea.
+        def onrejected
+          process! :rejected
+
+          head :accepted
+        end
+
+        private
+
+        # Envía la actividad para procesamiento por separado.
+        #
+        # @param initial_state [Symbol]
+        def process!(initial_state)
+          ::ActivityPub::ProcessJob
+            .set(wait: ApplicationJob.random_wait)
+            .perform_later(site: site, body: request.raw_post, initial_state: initial_state)
+        end
+      end
+    end
+  end
+end

app/controllers/application_controller.rb

@@ -3,18 +3,18 @@
 # Forma de ingreso a Sutty
 class ApplicationController < ActionController::Base
   include ExceptionHandler
+  include Pundit::Authorization
 
-  protect_from_forgery with: :exception
+  protect_from_forgery with: :null_session, prepend: true
 
   before_action :prepare_exception_notifier
   before_action :configure_permitted_parameters, if: :devise_controller?
+  before_action :notify_unconfirmed_email, unless: :devise_controller?
   around_action :set_locale
-
-  rescue_from ActionController::RoutingError, with: :page_not_found
-  rescue_from ActionController::ParameterMissing, with: :page_not_found
+  after_action :store_location!
 
   before_action do
-    Rack::MiniProfiler.authorize_request if current_usuarie&.email&.ends_with?('@' + ENV.fetch('SUTTY', 'sutty.nl'))
+    Rack::MiniProfiler.authorize_request if current_usuarie&.email&.ends_with?("@#{ENV.fetch('SUTTY', 'sutty.nl')}")
   end
 
   # No tenemos índice de sutty, vamos directamente a ver el listado de
@@ -23,10 +23,17 @@ class ApplicationController < ActionController::Base
     redirect_to sites_path
   end
 
-  def markdown; end
-
   private
 
+  def notify_unconfirmed_email
+    return unless current_usuarie
+    return if current_usuarie.confirmed?
+
+    I18n.with_locale(current_usuarie.lang) do
+      flash[:notice] ||= I18n.t('devise.registrations.signed_up')
+    end
+  end
+
   def uuid?(string)
     /[a-f0-9]{8}-([a-f0-9]{4}-){3}[a-f0-9]{12}/ =~ string
   end
@@ -35,32 +42,79 @@ class ApplicationController < ActionController::Base
   def find_site
     id = params[:site_id] || params[:id]
 
-    unless (site = current_usuarie.sites.find_by_name(id))
+    unless (site = current_usuarie&.sites&.find_by_name(id))
       raise SiteNotFound
     end
 
     site
   end
 
+  # Devuelve el idioma actual y si no lo encuentra obtiene uno por
+  # defecto.
+  #
+  # Esto se refiere al idioma de la interfaz, no de los artículos.
+  #
+  # @return [String,Symbol]
+  def current_locale
+    locale = params[:change_locale_to]
+
+    session[:locale] = params[:change_locale_to] if locale.present? && I18n.locale_available?(locale)
+
+    session[:locale] || current_usuarie&.lang || I18n.locale
+  end
+
   # El idioma es el preferido por le usuarie, pero no necesariamente se
   # corresponde con el idioma de los artículos, porque puede querer
   # traducirlos.
   def set_locale(&action)
-    I18n.with_locale(current_usuarie&.lang || I18n.default_locale, &action)
+    I18n.with_locale(current_locale, &action)
   end
 
-  # Muestra una página 404
-  def page_not_found
-    render 'application/page_not_found', status: :not_found
+  # Necesario para poder acceder a Blazer.  Solo les usuaries de este
+  # sitio pueden acceder al panel.
+  def require_usuarie
+    site = find_site
+    authorize SiteBlazer.new(site)
+
+    # Necesario para los breadcrumbs.
+    ActionView::Base.include Loaf::ViewExtensions unless ActionView::Base.included_modules.include? Loaf::ViewExtensions
+
+    breadcrumb current_usuarie.email, main_app.edit_usuarie_registration_path
+    breadcrumb 'sites.index', main_app.sites_path, match: :exact
+    breadcrumb site.title, main_app.site_path(site), match: :exact
+    breadcrumb 'stats.index', root_path, match: :exact
+  end
+
+  def site
+    @site ||= find_site
   end
 
   protected
 
   def configure_permitted_parameters
+    devise_parameter_sanitizer.permit(:sign_up, keys: Usuarie::CONSENT_FIELDS)
     devise_parameter_sanitizer.permit(:account_update, keys: %i[lang])
   end
 
   def prepare_exception_notifier
     request.env['exception_notifier.exception_data'] = { usuarie: current_usuarie }
   end
+
+  # Olvidar el idioma elegido antes de iniciar la sesión y reenviar a
+  # los sitios en el idioma de le usuarie.
+  def after_sign_in_path_for(resource)
+    session[:locale] = nil
+
+    super
+  end
+
+  # Guardar la ubicación para que devise redirija a donde íbamos, a
+  # menos que estemos recibiendo información o intentando ingresar.
+  def store_location!
+    return if request.xhr?
+    return unless request.request_method_symbol == :GET
+    return if devise_controller? && !is_a?(Devise::RegistrationsController) && params[:action] != 'edit'
+
+    session[:usuarie_return_to] = request.fullpath
+  end
 end

app/controllers/build_stats_controller.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+# La lista de estados de compilación, por ahora solo mostramos el último
+# estado.
+class BuildStatsController < ApplicationController
+  include ActionView::Helpers::NumberHelper
+  include ActionView::Helpers::DateHelper
+
+  before_action :authenticate_usuarie!
+
+  breadcrumb -> { current_usuarie.email }, :edit_usuarie_registration_path
+  breadcrumb 'sites.index', :sites_path, match: :exact
+  breadcrumb -> { site.title }, -> { site_posts_path(site, locale: locale) }, match: :exact
+
+  def index
+    authorize SiteBuildStat.new(site)
+    breadcrumb I18n.t('build_stats.index.title'), ''
+
+    @headers = %w[type url seconds size].map do |header|
+      t("deploy_mailer.deployed.th.#{header}")
+    end
+
+    @table = site.deployment_list.map do |deploy|
+      type = deploy.class.name.underscore
+      urls = deploy.urls.map do |url|
+        URI.parse(url)
+      rescue URI::Error
+        nil
+      end.compact
+
+      urls = [nil] if urls.empty?
+      build_stat = deploy.build_stats.where(status: true).last
+      seconds = build_stat&.seconds || 0
+
+      {
+        title: t("deploy_mailer.deployed.#{type}.title"),
+        urls: urls,
+        seconds: {
+          human: distance_of_time_in_words(seconds),
+          machine: "PT#{seconds}S"
+        },
+        size: number_to_human_size(build_stat&.bytes || 0, precision: 2)
+      }
+    end
+  end
+end

app/controllers/concerns/active_storage/authenticated_direct_uploads_controller.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module ActiveStorage
+  module AuthenticatedDirectUploadsController
+    extend ActiveSupport::Concern
+
+    included do
+      before_action :authenticate_usuarie!
+    end
+  end
+end

app/controllers/concerns/blazer_decorator.rb

@@ -0,0 +1,194 @@
+# frozen_string_literal: true
+
+# Modificaciones para Blazer
+module BlazerDecorator
+  # No poder obtener información de la base de datos.
+  module DisableDatabaseInfo
+    extend ActiveSupport::Concern
+
+    included do
+      def docs; end
+
+      def tables; end
+
+      def schema; end
+    end
+  end
+
+  # Deshabilitar edición de consultas y chequeos.
+  module DisableEdits
+    extend ActiveSupport::Concern
+
+    included do
+      def create; end
+
+      def update; end
+
+      def destroy; end
+
+      def run; end
+
+      def refresh; end
+
+      def cancel; end
+    end
+  end
+
+  # Blazer hace un gran esfuerzo para ejecutar consultas de forma
+  # asincrónica pero termina enviándolas por JS.
+  module RunSync
+    extend ActiveSupport::Concern
+
+    included do
+      alias_method :original_show, :show
+
+      include Blazer::BaseHelper
+
+      def show
+        original_show
+
+        options = { user: blazer_user, query: @query, run_id: SecureRandom.uuid, async: false }
+        @data_source = Blazer.data_sources[@query.data_source]
+        @result = Blazer::RunStatement.new.perform(@data_source, @statement, options)
+        chart_data
+      end
+
+      private
+
+      # Solo mostrar las consultas de le usuarie
+      def set_queries(_ = nil)
+        @queries = (@current_usuarie || current_usuarie).blazer_queries
+      end
+
+      # blazer-2.4.2/app/views/blazer/queries/run.html.erb
+      def chart_type
+        case @result.chart_type
+        when /\Aline(2)?\z/
+          chart_options.merge! min: nil
+        when /\Abar(2)?\z/
+          chart_options.merge! library: { tooltips: { intersect: false, axis: 'x' } }
+        when 'pie'
+          chart_options
+        when 'scatter'
+          chart_options.merge! library: { tooltips: { intersect: false } }, xtitle: @result.columns[0],
+                               ytitle: @result.columns[1]
+        when nil
+        else
+          if @result.column_types.size == 2
+            chart_options.merge! library: { tooltips: { intersect: false, axis: 'x' } }
+          else
+            chart_options.merge! library: { tooltips: { intersect: false } }
+          end
+        end
+
+        @result.chart_type
+      end
+
+      def chart_data
+        @chart_data ||=
+          case chart_type
+          when 'line'
+            @result.columns[1..-1].each_with_index.map do |k, i|
+              {
+                name: blazer_series_name(k),
+                data: @result.rows.map do |r|
+                  [r[0], r[i + 1]]
+                end,
+                library: series_library[i]
+              }
+            end
+          when 'line2'
+            @result.rows.group_by do |r|
+              v = r[1]
+              (@result.boom[@result.columns[1]] || {})[v.to_s] || v
+            end.each_with_index.map do |(name, v), i|
+              {
+                name: blazer_series_name(name),
+                data: v.map do |v2|
+                  [v2[0], v2[2]]
+                end,
+                library: series_library[i]
+              }
+            end
+          when 'pie'
+            @result.rows.map do |r|
+              [(@result.boom[@result.columns[0]] || {})[r[0].to_s] || r[0], r[1]]
+            end
+          when 'bar'
+            (@result.rows.first.size - 1).times.map do |i|
+              name = @result.columns[i + 1]
+
+              {
+                name: blazer_series_name(name),
+                data: @result.rows.first(20).map do |r|
+                  [(@result.boom[@result.columns[0]] || {})[r[0].to_s] || r[0], r[i + 1]]
+                end
+              }
+            end
+          when 'bar2'
+            first_20 = @result.rows.group_by { |r| r[0] }.values.first(20).flatten(1)
+            labels = first_20.map { |r| r[0] }.uniq
+            series = first_20.map { |r| r[1] }.uniq
+            labels.each do |l|
+              series.each do |s|
+                first_20 << [l, s, 0] unless first_20.find { |r| r[0] == l && r[1] == s }
+              end
+            end
+
+            first_20.group_by do |r|
+              v = r[1]
+              (@result.boom[@result.columns[1]] || {})[v.to_s] || v
+            end.each_with_index.map do |(name, v), _i|
+              {
+                name: blazer_series_name(name),
+                data: v.sort_by do |r2|
+                  labels.index(r2[0])
+                end.map do |v2|
+                  v3 = v2[0]
+                  [(@result.boom[@result.columns[0]] || {})[v3.to_s] || v3, v2[2]]
+                end
+              }
+            end
+          when 'scatter'
+            @result.rows
+          end
+      end
+
+      def target_index
+        @target_index ||= @result.columns.index do |k|
+          k.downcase == 'target'
+        end
+      end
+
+      def series_library
+        @series_library ||= {}.tap do |sl|
+          if target_index
+            color = '#109618'
+            sl[target_index - 1] = {
+              pointStyle: 'line',
+              hitRadius: 5,
+              borderColor: color,
+              pointBackgroundColor: color,
+              backgroundColor: color,
+              pointHoverBackgroundColor: color
+            }
+          end
+        end
+      end
+
+      def chart_options
+        @chart_options ||= { id: SecureRandom.hex }
+      end
+    end
+  end
+end
+
+classes = [Blazer::QueriesController, Blazer::ChecksController, Blazer::DashboardsController]
+modules = [BlazerDecorator::DisableDatabaseInfo, BlazerDecorator::DisableEdits]
+classes.each do |klass|
+  modules.each do |modul|
+    klass.include modul unless klass.included_modules.include? modul
+  end
+end
+
+Blazer::QueriesController.include BlazerDecorator::RunSync

app/controllers/concerns/exception_handler.rb

@@ -12,13 +12,31 @@ module ExceptionHandler
     rescue_from PageNotFound, with: :page_not_found
     rescue_from ActionController::RoutingError, with: :page_not_found
     rescue_from Pundit::NilPolicyError, with: :page_not_found
+    rescue_from Pundit::NilPolicyError, with: :page_not_found
+    rescue_from ActionController::RoutingError, with: :page_not_found
+    rescue_from ActionController::ParameterMissing, with: :page_not_found
   end
 
   def site_not_found
+    reset_response!
+
+    flash[:error] = I18n.t('errors.site_not_found')
+
     redirect_to sites_path
   end
 
   def page_not_found
-    send_file Rails.root.join('public', '404.html')
+    reset_response!
+
+    render 'application/page_not_found', status: :not_found
+  end
+
+  private
+
+  def reset_response!
+    self.response_body = nil
+    @_response_body = nil
+
+    headers.delete('Location')
   end
 end

app/controllers/concerns/moderation_concern.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module ModerationConcern
+  extend ActiveSupport::Concern
+
+  included do
+    private
+
+    def redirect_to_moderation_queue!
+      redirect_back fallback_location: site_moderation_queue_path(**(session[:moderation_queue_filters] || {}))
+    end
+
+    # @return [String]
+    def panel_actor_mention
+      @panel_actor_mention ||= ENV.fetch('PANEL_ACTOR_MENTION', '@sutty@sutty.nl')
+    end
+
+    def remote_flag_params(model)
+      remote_flag = ActivityPub::RemoteFlag.find_by(actor_id: model.actor_id)
+
+      { remote_flag_attributes: { id: remote_flag&.id, message: ''.dup } }.tap do |p|
+        p[:remote_flag_attributes][:site_id] = model.site_id
+        p[:remote_flag_attributes][:actor_id] = model.actor_id
+
+        I18n.available_locales.each do |locale|
+          p[:remote_flag_attributes][:message].tap do |m|
+            m << I18n.t(locale)
+            m << ': '
+            m << I18n.t('remote_flags.report_message', locale: locale, panel_actor_mention: panel_actor_mention)
+            m << '\n\n'
+          end
+        end
+      end
+    end
+  end
+end

app/controllers/concerns/moderation_filters_concern.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module ModerationFiltersConcern
+  extend ActiveSupport::Concern
+
+  included do
+    before_action :store_filters_in_session!, only: %i[index show]
+
+    private
+
+    def store_filters_in_session!
+      session[:moderation_queue_filters] = params.permit(:instance_state, :actor_state, :activity_pub_state)
+    end
+  end
+end

app/controllers/env_controller.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+class EnvController < ActionController::Base
+  skip_before_action :verify_authenticity_token
+
+  def index
+    @site = Site.find_by_name('panel') || Site.first
+
+    stale? @site if @site
+  end
+end

app/controllers/fediblock_states_controller.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+# Estado de las listas de bloqueo en cada sitio
+class FediblockStatesController < ApplicationController
+  # Realiza cambios en las listas de bloqueo
+  def action_on_several
+    # Encontrar todas y deshabilitar las que no se enviaron
+    site.fediblock_states.all.find_each do |fediblock_state|
+      if fediblock_states_ids.include? fediblock_state.id
+        fediblock_state.enable! if fediblock_state.may_enable?
+      elsif fediblock_state.may_disable?
+        fediblock_state.disable!
+      end
+
+      flash[:success] = I18n.t('fediblock_states.action_on_several.success')
+    rescue Exception => e
+      ExceptionNotifier.notify_exception(e, data: { site: site.name })
+
+      flash.delete(:success)
+      flash[:error] = I18n.t('fediblock_states.action_on_several.error')
+    end
+
+    # Bloquear otras instancias
+    if custom_blocklist.present?
+      if ActivityPub::InstanceModerationJob.perform_now(site: site, hostnames: custom_blocklist)
+        flash[:success] = I18n.t('fediblock_states.action_on_several.custom_blocklist_success')
+      else
+        flash[:error] = I18n.t('fediblock_states.action_on_several.custom_blocklist_error')
+      end
+    end
+
+    redirect_to site_moderation_queue_path
+  end
+
+  private
+
+  def fediblock_states_ids
+    params[:fediblock_states_ids] || []
+  end
+
+  # La lista de hostnames
+  def custom_blocklist
+    @custom_blocklist ||= fediblocks_states_params[:custom_blocklist].split("\n").map(&:strip).select(&:present?)
+  end
+
+  def fediblocks_states_params
+    @fediblocks_states_params ||= params.permit(:custom_blocklist, fediblock_states_ids: [])
+  end
+end

app/controllers/instance_moderations_controller.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+# Actualiza la relación entre un sitio y una instancia
+class InstanceModerationsController < ApplicationController
+  include ModerationConcern
+
+  InstanceModeration.events.each do |event|
+    define_method(event) do
+      authorize instance_moderation
+
+      message =
+        if instance_moderation.public_send(:"may_#{event}?") && instance_moderation.public_send(:"#{event}!")
+          :success
+        else
+          :error
+        end
+
+      flash[message] = I18n.t("instance_moderations.#{event}.#{message}")
+
+      redirect_to_moderation_queue!
+    end
+  end
+
+  def action_on_several
+    redirect_to_moderation_queue!
+
+    instance_moderations = site.instance_moderations.where(id: params[:instance_moderation])
+
+    return if instance_moderations.count.zero?
+
+    authorize instance_moderations
+
+    action = params[:instance_moderation_action].to_sym
+    method = :"#{action}_all!"
+
+    return unless InstanceModeration.events.include? action
+
+    InstanceModeration.transaction do
+      message = instance_moderations.public_send(method) ? :success : :error
+
+      flash[:message] = I18n.t("instance_moderations.action_on_several.#{message}")
+    end
+  end
+
+  private
+
+  # @return [InstanceModeration]
+  def instance_moderation
+    @instance_moderation ||= site.instance_moderations.find(params[:instance_moderation_id])
+  end
+end

app/controllers/moderation_queue_controller.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+# Cola de moderación de ActivityPub
+class ModerationQueueController < ApplicationController
+  include ModerationFiltersConcern
+
+  before_action :authenticate_usuarie!
+
+  breadcrumb -> { current_usuarie.email }, :edit_usuarie_registration_path
+  breadcrumb 'sites.index', :sites_path, match: :exact
+
+  # Cola de moderación viendo todo el sitio
+  def index
+    authorize ModerationQueue.new(site)
+    breadcrumb site.title, site_posts_path(site)
+    breadcrumb I18n.t('moderation_queue.index.title'), ''
+
+    site.moderation_checked!
+
+    # @todo cambiar el estado por query
+    @activity_pubs = site.activity_pubs
+    @instance_moderations = rubanok_process(site.instance_moderations, with: InstanceModerationProcessor)
+    @actor_moderations = rubanok_process(site.actor_moderations, with: ActorModerationProcessor)
+    @moderation_queue = rubanok_process(site.activity_pubs, with: ActivityPubProcessor)
+  end
+end

app/controllers/posts_controller.rb

@@ -2,85 +2,73 @@
 
 # Controlador para artículos
 class PostsController < ApplicationController
-  include Pundit
-  rescue_from Pundit::NilPolicyError, with: :page_not_found
-
   before_action :authenticate_usuarie!
+  before_action :service_for_direct_upload, only: %i[new edit]
+
+  # TODO: Traer los comunes desde ApplicationController
+  breadcrumb -> { current_usuarie.email }, :edit_usuarie_registration_path
+  breadcrumb 'sites.index', :sites_path, match: :exact
+  breadcrumb -> { site.title }, -> { site_posts_path(site, locale: locale) }, match: :exact
 
   # Las URLs siempre llevan el idioma actual o el de le usuarie
   def default_url_options
-    { locale: params[:locale] || current_usuarie&.lang || I18n.locale }
+    { locale: locale }
   end
 
   def index
     authorize Post
 
-    @site = find_site
-    @category = params.dig(:category)
-    @layout = params.dig(:layout)
-    @locale = locale
-
     # XXX: Cada vez que cambiamos un Post tocamos el sitio con lo que es
     # más simple saber si hubo cambios.
-    if @category || @layout || stale?(@site)
-      @posts = @site.posts(lang: locale)
-      @posts = @posts.where(categories: @category) if @category
-      @posts = @posts.where(layout: @layout) if @layout
-      @posts = PostPolicy::Scope.new(current_usuarie, @posts).resolve
+    return unless stale?([current_usuarie, site, filter_params])
 
-      @category_name = if uuid?(@category)
-                         @site.posts(lang: locale).find(@category, uuid: true)&.title&.value
-                       else
-                         @category
-                       end
+    # Todos los artículos de este sitio para el idioma actual
+    @posts = site.indexed_posts.where(locale: locale)
+    @posts = @posts.page(filter_params.delete(:page)) if site.pagination
+    # De este tipo
+    @posts = @posts.where(layout: filter_params[:layout]) if filter_params[:layout]
+    # Que estén dentro de la categoría
+    @posts = @posts.in_category(filter_params[:category]) if filter_params[:category]
+    # Aplicar los parámetros de búsqueda
+    @posts = @posts.search(locale, filter_params[:q]) if filter_params[:q].present?
+    # A los que este usuarie tiene acceso
+    @posts = PostPolicy::Scope.new(current_usuarie, @posts).resolve
 
-      # Filtrar los posts que les invitades no pueden ver
-      @usuarie = @site.usuarie? current_usuarie
+    # Filtrar los posts que les invitades no pueden ver
+    @usuarie = site.usuarie? current_usuarie
 
-      # Orden descendiente por número y luego por fecha
-      @posts.sort_by!(:order, :date).reverse!
-    end
+    @site_stat = SiteStat.new(site)
   end
 
   def show
-    @site = find_site
-    @post = @site.posts(lang: locale).find params[:id]
-
-    authorize @post
-    @locale = locale
-
-    fresh_when @post
+    authorize post
+    breadcrumb post.title.value, ''
+    fresh_when post
   end
 
   # Genera una previsualización del artículo.
-  #
-  # TODO: No todos los artículos tienen previsualización!
   def preview
-    @site = find_site
-    @post = @site.posts(lang: locale).find params[:post_id]
+    authorize post
 
-    authorize @post
-
-    render html: @post.render
+    render html: post.render
   end
 
   def new
     authorize Post
-    @site = find_site
-    @post = @site.posts.build(lang: locale, layout: params[:layout])
-    @locale = locale
+    @post = site.posts(lang: locale).build(layout: params[:layout])
+
+    breadcrumb I18n.t('loaf.breadcrumbs.posts.new', layout: @post.layout.humanized_name.downcase), ''
   end
 
   def create
     authorize Post
-    @site = find_site
-    service = PostService.new(site: @site,
+    service = PostService.new(site: site,
                               usuarie: current_usuarie,
                               params: params)
     @post = service.create
 
     if @post.persisted?
-      @site.touch
+      site.touch
       forget_content
 
       redirect_to site_post_path(@site, @post)
@@ -90,30 +78,24 @@ class PostsController < ApplicationController
   end
 
   def edit
-    @site = find_site
-    @post = @site.posts(lang: locale).find params[:id]
-
-    authorize @post
-
-    @locale = locale
+    authorize post
+    breadcrumb post.title.value, site_post_path(site, post, locale: locale), match: :exact
+    breadcrumb 'posts.edit', ''
   end
 
   def update
-    @site = find_site
-    @post = @site.posts(lang: locale).find params[:id]
+    authorize post
 
-    authorize @post
-
-    service = PostService.new(site: @site,
-                              post: @post,
+    service = PostService.new(site: site,
+                              post: post,
                               usuarie: current_usuarie,
                               params: params)
 
     if service.update.persisted?
-      @site.touch
+      site.touch
       forget_content
 
-      redirect_to site_post_path(@site, @post)
+      redirect_to site_post_path(site, post)
     else
       render 'posts/edit'
     end
@@ -121,34 +103,30 @@ class PostsController < ApplicationController
 
   # Eliminar artículos
   def destroy
-    @site = find_site
-    @post = @site.posts(lang: locale).find params[:id]
+    authorize post
 
-    authorize @post
-
-    service = PostService.new(site: @site,
-                              post: @post,
+    service = PostService.new(site: site,
+                              post: post,
                               usuarie: current_usuarie,
                               params: params)
 
     # TODO: Notificar si se pudo o no
     service.destroy
-    @site.touch
-    redirect_to site_posts_path(@site)
+    site.touch
+    redirect_to site_posts_path(site, locale: post.lang.value)
   end
 
   # Reordenar los artículos
   def reorder
-    @site = find_site
-    authorize @site
+    authorize site
 
-    service = PostService.new(site: @site,
+    service = PostService.new(site: site,
                               usuarie: current_usuarie,
                               params: params)
 
     service.reorder
-    @site.touch
-    redirect_to site_posts_path(@site)
+    site.touch
+    redirect_to site_posts_path(site, locale: site.default_locale)
   end
 
   # Devuelve el idioma solicitado a través de un parámetro, validando
@@ -159,14 +137,35 @@ class PostsController < ApplicationController
   # solicite a le usuarie crear el nuevo idioma y que esto lo agregue al
   # _config.yml del sitio en lugar de mezclar idiomas.
   def locale
-    @site&.locales&.find(-> { I18n.locale.to_s }) do |l|
-      l == params[:locale]
+    @locale ||= site&.locales&.find(-> { site&.default_locale }) do |l|
+      l.to_s == params[:locale]
     end
   end
 
   # Instruye al editor a olvidarse el contenido del artículo.  Usar
   # cuando hayamos guardado la información correctamente.
   def forget_content
-    flash[:js] = { target: 'editor', action: 'forget-content', keys: params[:storage_keys].to_json }
+    flash[:js] = { target: 'editor', action: 'forget-content', keys: (params[:storage_keys] || []).to_json }
+  end
+
+  private
+
+  # Los parámetros de filtros que vamos a mantener en todas las URLs,
+  # solo los que no estén vacíos.
+  #
+  # @return [Hash]
+  def filter_params
+    @filter_params ||= params.permit(:q, :category, :layout, :page).to_hash.select do |_, v|
+      v.present?
+    end.transform_keys(&:to_sym)
+  end
+
+  def post
+    @post ||= site.posts(lang: locale).find(params[:post_id] || params[:id])
+  end
+
+  # Recuerda el nombre del servicio de subida de archivos
+  def service_for_direct_upload
+    session[:service_name] = site.name.to_sym
   end
 end

app/controllers/private_controller.rb

@@ -6,8 +6,6 @@ class PrivateController < ApplicationController
   # XXX: Permite ejecutar JS
   skip_forgery_protection
 
-  include Pundit
-
   # Enviar el archivo si existe, agregar una / al final siempre para no
   # romper las direcciones relativas.
   def show

app/controllers/sites_controller.rb

@@ -2,32 +2,45 @@
 
 # Controlador de sitios
 class SitesController < ApplicationController
-  include Pundit
-  rescue_from Pundit::NilPolicyError, with: :page_not_found
-
   before_action :authenticate_usuarie!
 
+  breadcrumb -> { current_usuarie.email }, :edit_usuarie_registration_path
+  breadcrumb 'sites.index', :sites_path, match: :exact
+
   # Ver un listado de sitios
   def index
     authorize Site
-    @sites = current_usuarie.sites.order(:title)
+    @sites = current_usuarie.sites.order(updated_at: :desc)
 
     fresh_when @sites
   end
 
+  # Genera la caja del estado para HTMX
+  def status
+    authorize site
+
+    render('sites/status', layout: false) if stale? site
+  end
+
+  def button
+    authorize site
+
+    render('sites/build', layout: false)
+  end
+
   # No tenemos propiedades de un sitio aún, así que vamos al listado de
   # artículos
   def show
     authorize site
 
-    redirect_to site_posts_path(site)
+    redirect_to site_posts_path(site, locale: site.default_locale)
   end
 
   def new
+    breadcrumb 'sites.new', :new_site_path
+
     @site = Site.new
     authorize @site
-
-    @site.deploys.build type: 'DeployLocal'
   end
 
   def create
@@ -35,7 +48,7 @@ class SitesController < ApplicationController
                               params: site_params)
 
     if (@site = service.create).persisted?
-      redirect_to site_posts_path(@site)
+      redirect_to site_posts_path(@site, locale: @site.default_locale)
     else
       render 'new'
     end
@@ -43,6 +56,10 @@ class SitesController < ApplicationController
 
   def edit
     authorize site
+
+    breadcrumb site.title, site_posts_path(site, locale: site.default_locale), match: :exact
+    breadcrumb 'sites.edit', site_path(site)
+
     SiteService.new(site: site).build_deploys
   end
 
@@ -53,7 +70,8 @@ class SitesController < ApplicationController
                               usuarie: current_usuarie)
 
     if service.update.valid?
-      redirect_to site_posts_path(site)
+      flash[:notice] = I18n.t('sites.update.post')
+      redirect_to site_posts_path(site, locale: site.default_locale)
     else
       render 'edit'
     end
@@ -62,10 +80,9 @@ class SitesController < ApplicationController
   def enqueue
     authorize site
 
-    # XXX: Convertir en una máquina de estados?
-    DeployJob.perform_async site.id if site.enqueue!
+    SiteService.new(site: site).deploy
 
-    redirect_to site_posts_path(site)
+    redirect_to site_posts_path(site, locale: site.default_locale)
   end
 
   def reorder_posts
@@ -85,7 +102,7 @@ class SitesController < ApplicationController
       flash[:danger] = I18n.t('errors.posts.reorder')
     end
 
-    redirect_to site_posts_path(site)
+    redirect_to site_posts_path(site, locale: site.default_locale)
   end
 
   def fetch
@@ -97,7 +114,7 @@ class SitesController < ApplicationController
   def merge
     authorize site
 
-    if site.repository.merge(current_usuarie)
+    if SiteService.new(site: site, usuarie: current_usuarie).merge
       flash[:success] = I18n.t('sites.fetch.merge.success')
     else
       flash[:error] = I18n.t('sites.fetch.merge.error')
@@ -106,27 +123,6 @@ class SitesController < ApplicationController
     redirect_to sites_path
   end
 
-  # Obtiene y streamea archivos estáticos desde el repositorio mismo,
-  # pero sólo los públicos (es decir los archivos subidos desde Sutty).
-  def static_file
-    authorize site
-
-    file = params.require(:file) + '.' + params.require(:format)
-
-    raise ActionController::RoutingError.new(nil, nil) unless file.start_with? 'public/'
-
-    path = site.relative_path file
-
-    raise ActionController::RoutingError.new(nil, nil) unless File.exist? path
-
-    # TODO: Hacer esto usa recursos, pero menos que generar el sitio
-    # cada vez.  Para poder usar X-Accel tendríamos que montar los
-    # repositorios en el servidor web, cosa que no queremos, o hacer
-    # links simbólicos desde todos los public, o usar un servidor web
-    # local que soporte sendfile mejor que Rails (nghttpd?)
-    send_file path
-  end
-
   private
 
   def site

app/controllers/stats_controller.rb

@@ -3,16 +3,223 @@
 # Estadísticas del sitio
 class StatsController < ApplicationController
   include Pundit
+  include ActionView::Helpers::DateHelper
+
   before_action :authenticate_usuarie!
+  before_action :authorize_stats
+
+  breadcrumb -> { current_usuarie.email }, :edit_usuarie_registration_path
+  breadcrumb 'sites.index', :sites_path, match: :exact
+  breadcrumb -> { site.title }, -> { site_posts_path(site, locale: locale) }, match: :exact
+
+  EXTRA_OPTIONS = {
+    builds: {},
+    space_used: { bytes: true },
+    build_time: {}
+  }.freeze
+
+  # XXX: Permitir a Chart.js inyectar su propio CSS
+  content_security_policy only: :index do |policy|
+    policy.style_src :self, :unsafe_inline
+    policy.script_src :self, :unsafe_inline
+  end
+
+  # Parámetros por defecto
+  #
+  # @return [Hash]
+  def default_url_options
+    { interval: 'day', period_start: Date.today.beginning_of_year, period_end: Date.today }
+  end
 
   def index
-    @site = find_site
-    authorize SiteStat.new(@site)
+    breadcrumb I18n.t('stats.index.title'), ''
 
-    # Solo queremos el promedio de tiempo de compilación, no de
-    # instalación de dependencias.
-    stats = @site.build_stats.jekyll
-    @build_avg = stats.average(:seconds).to_f.round(2)
-    @build_max = stats.maximum(:seconds).to_f.round(2)
+    params.with_defaults! default_url_options
+
+    @chart_params = {
+      interval: interval,
+      period_start: params[:period_start],
+      period_end: params[:period_end]
+    }
+
+    hostnames
+    last_stat
+    chart_options
+    normalized_urls
+
+    expires_in = Time.now.try(:"end_of_#{Stat.default_interval}") - Time.now
+    @columns = {}
+
+    Stat::COLUMNS.each do |column|
+      @columns[column] =
+        Rails.cache.fetch("stats/#{column}/#{site.id}", expires_in: expires_in) do
+          rollup_scope.where(interval: interval, name: "host|#{column}")
+                      .where_dimensions(host: hostnames)
+                      .group("dimensions->>'#{column}'")
+                      .order('sum(value) desc')
+                      .sum(:value)
+                      .transform_values(&:to_i)
+                      .transform_values do |v|
+                        v * nodes
+                      end
+        end
+    end
+  end
+
+  # Genera un gráfico de visitas por dominio asociado a este sitio
+  def host
+    return unless stale? [last_stat, hostnames, interval, period]
+
+    stats = rollup_scope.where_dimensions(host: hostnames).multi_series('host', interval: interval).tap do |series|
+      series.each do |serie|
+        serie[:name] = serie.dig(:dimensions, 'host')
+        serie[:data].transform_values! do |value|
+          value * nodes
+        end
+      end
+    end
+
+    render json: stats
+  end
+
+  def resources
+    return unless stale? [last_stat, interval, resource, period]
+
+    options = { interval: interval, dimensions: { site_id: site.id } }
+
+    render json: rollup_scope.series(resource, **options)
+  end
+
+  def uris
+    return unless stale? [last_stat, hostnames, interval, normalized_urls, period]
+
+    options = { host: hostnames, uri: normalized_paths }
+    # XXX: where_dimensions es más corto pero no aprovecha los índices
+    # de Rollup
+    stats = rollup_scope.where_dimensions(**options).multi_series('host|uri', interval: interval).tap do |series|
+      series.each do |serie|
+        serie[:name] = serie[:dimensions].slice('host', 'uri').values.join.sub('/index.html', '/')
+        serie[:data].transform_values! do |value|
+          value * nodes
+        end
+      end
+    end
+
+    render json: stats
+  end
+
+  private
+
+  def rollup_scope
+    Rollup.where(time: period)
+  end
+
+  def last_stat
+    @last_stat ||= site.stats.last
+  end
+
+  def authorize_stats
+    authorize SiteStat.new(site)
+  end
+
+  # TODO: Eliminar cuando mergeemos referer-origin
+  def hostnames
+    @hostnames ||= site.hostnames
+  end
+
+  # Normalizar las URLs
+  #
+  # @return [Array]
+  def normalized_urls
+    @normalized_urls ||=
+      begin
+        urls = params[:urls].is_a?(Array) ? params[:urls] : params[:urls]&.split("\n")
+        urls = urls&.map(&:strip)&.select(&:present?)&.select do |uri|
+          uri.start_with? 'https://'
+        end
+
+        urls ||= [site.url]
+
+        urls.map do |u|
+          # XXX: Eliminar al deployear
+          # @see {https://0xacab.org/sutty/containers/nginx/-/merge_requests/1}
+          next u unless u.end_with? '/'
+
+          "#{u}index.html"
+        end.uniq
+      end
+  end
+
+  def normalized_paths
+    @normalized_paths ||= normalized_urls.map do |u|
+      "/#{u.split('/', 4).last}"
+    end.map do |u|
+      URI.decode_www_form_component u
+    end
+  end
+
+  # Opciones por defecto para los gráficos.
+  #
+  # La invitación a volver dentro de X tiempo es para dar un estimado de
+  # cuándo habrá información disponible, porque Rollup genera intervalos
+  # completos (¿aunque dice que no?)
+  #
+  # La diferencia se calcula sumando el intervalo a la hora de última
+  # toma de estadísticas y restando el tiempo que pasó desde ese
+  # momento.
+  def chart_options
+    time = (last_stat&.created_at || Time.now) + 1.try(interval)
+    please_return_at = { please_return_at: distance_of_time_in_words(Time.now, time) }
+
+    @chart_options ||= {
+      locale: I18n.locale,
+      empty: I18n.t('stats.index.empty', **please_return_at),
+      loading: I18n.t('stats.index.loading'),
+      html: %(<div id="%{id}" class="d-flex align-items-center justify-content-center" style="height: %{height}; width: %{width};">%{loading}</div>)
+    }
+  end
+
+  # Obtiene y valida los intervalos
+  #
+  # @return [Symbol]
+  def interval
+    @interval ||= begin
+      i = params[:interval]&.to_sym
+      Stat::INTERVALS.include?(i) ? i : Stat::INTERVALS.first
+    end
+  end
+
+  # @return [Symbol]
+  def resource
+    @resource ||= begin
+      r = params[:resource].to_sym
+      Stat::RESOURCES.include?(r) ? r : Stat::RESOURCES.first
+    end
+  end
+
+  # Obtiene la cantidad de nodos de Sutty, para poder calcular la
+  # cantidad de visitas.
+  #
+  # Como repartimos las visitas por nodo rotando las IPs en el
+  # nameserver y los resolvedores de DNS eligen un nameserver
+  # aleatoriamente, la cantidad de visitas se reparte
+  # equitativamente.
+  #
+  # XXX: Remover cuando podamos centralizar los AccessLog
+  #
+  # @return [Integer]
+  def nodes
+    @nodes ||= ENV.fetch('NODES', 1).to_i
+  end
+
+  def period
+    @period ||= begin
+      p = params.permit(:period_start, :period_end)
+      p[:period_start]..p[:period_end]
+    end
+  end
+
+  def site
+    @site ||= find_site
   end
 end

app/controllers/usuaries_controller.rb

@@ -7,12 +7,18 @@ class UsuariesController < ApplicationController
   include Pundit
   before_action :authenticate_usuarie!
 
+  # TODO: Traer los comunes desde ApplicationController
+  breadcrumb -> { current_usuarie.email }, :edit_usuarie_registration_path
+  breadcrumb 'sites.index', :sites_path, match: :exact
+  breadcrumb -> { site.title }, -> { site_posts_path(site, locale: locale) }, match: :exact
+
   # Mostrar todes les usuaries e invitades de un sitio
   def index
-    @site = find_site
-    site_usuarie = SiteUsuarie.new(@site, current_usuarie)
+    site_usuarie = SiteUsuarie.new(site, current_usuarie)
     authorize site_usuarie
 
+    breadcrumb 'usuaries.index', ''
+
     @policy = policy(site_usuarie)
   end
 
@@ -41,7 +47,7 @@ class UsuariesController < ApplicationController
     @usuarie = Usuarie.find(params[:usuarie_id])
 
     if @site.usuaries.count > 1
-      @usuarie.rol_for_site(@site).update_attribute :rol, 'invitade'
+      @usuarie.rol_for_site(@site).update_attribute :rol, Rol::INVITADE
     else
       flash[:warning] = I18n.t('usuaries.index.demote.denied')
     end
@@ -55,7 +61,7 @@ class UsuariesController < ApplicationController
     authorize SiteUsuarie.new(@site, current_usuarie)
 
     @usuarie = Usuarie.find(params[:usuarie_id])
-    @usuarie.rol_for_site(@site).update_attribute :rol, 'usuarie'
+    @usuarie.rol_for_site(@site).update_attribute :rol, Rol::USUARIE
 
     redirect_to site_usuaries_path
   end
@@ -66,6 +72,8 @@ class UsuariesController < ApplicationController
     site_usuarie = SiteUsuarie.new(@site, current_usuarie)
     authorize site_usuarie
 
+    params[:invite_as] = invite_as
+
     @policy = policy(site_usuarie)
   end
 
@@ -75,27 +83,33 @@ class UsuariesController < ApplicationController
     authorize SiteUsuarie.new(@site, current_usuarie)
 
     # Enviar la invitación si es necesario y agregar al sitio
-    invitaciones.each do |invitacion|
-      # Si la cuenta no existe, envía una invitación por correo, sino,
-      # no se envía nada
-      #
-      # TODO: Enviar invitación igual!  Podemos no usar el Mailer de
-      # DeviseInvitations y usar uno propio que contenga texto y se
-      # envíe de todas formas.
-      usuarie = Usuarie.invite! email: invitacion.address,
-                                skip_invitation: true
+    invitaciones.each do |address|
+      next if Usuarie.where(id: @site.roles.pluck(:usuarie_id)).find_by_email(address)
 
-      # No invitar al sitio si ya estaba en la lista!
-      #
-      # XXX: En este caso no estamos enviando ninguna invitación
-      next if usuarie.sites.exists? @site.id
+      Usuarie.transaction do
+        usuarie   = Usuarie.find_by_email(address)
+        usuarie ||= Usuarie.invite!({ email: address, skip_invitation: true }).tap do |u|
+          u.send :generate_invitation_token!
+        end
 
-      @site.roles << Rol.create(usuarie: usuarie, site: @site,
-                                temporal: true, rol: invited_as)
+        role = @site.roles.create(usuarie: usuarie, temporal: true, rol: invited_as)
 
-      # Invitamos después de crear el rol para que el correo de
-      # invitación pueda recibir el sitio.
-      usuarie.deliver_invitation
+        # XXX: La invitación tiene que ser enviada luego de crear el rol
+        if role.persisted?
+          # Si es una cuenta manual que no está confirmada aun,
+          # aprovechar para reconfirmarla.
+          if !usuarie.confirmed? && !usuarie.created_by_invite?
+            usuarie.confirmation_token = nil
+            usuarie.send :generate_confirmation_token!
+          end
+
+          usuarie.deliver_invitation
+        else
+          raise ArgumentError, role.errors.full_messages
+        end
+      rescue ArgumentError => e
+        ExceptionNotifier.notify_exception(e, data: { site: @site.name, address: address })
+      end
     end
 
     redirect_to site_usuaries_path(@site)
@@ -104,16 +118,21 @@ class UsuariesController < ApplicationController
   # Aceptar la invitación
   def accept_invitation
     @site = find_site
+    rol = current_usuarie.rol_for_site(@site)
 
     # Le usuarie ya aceptó la invitación
-    if site.usuarie?(current_usuarie) || site.invitade?(current_usuarie)
+    unless rol&.temporal
       redirect_to sites_path
       return
     end
 
     authorize SiteUsuarie.new(@site, current_usuarie)
 
-    @site.touch if current_usuarie.rol_for_site(@site).update_attribute :temporal, false
+    Rol.transaction do
+      rol.update(temporal: false) &&
+        current_usuarie.update(invitation_token: nil) &&
+        @site.touch
+    end
 
     redirect_to sites_path
   end
@@ -131,26 +150,32 @@ class UsuariesController < ApplicationController
   private
 
   # Traer todas las invitaciones que al menos tengan usuarie y dominio
+  #
+  # @return [Array]
   def invitaciones
     # XXX: Podríamos usar EmailAddress pero hace chequeos más lentos
-    i = params[:invitaciones].split("\n").map do |m|
+    params[:invitaciones]&.tr("\r", '')&.split("\n")&.map do |m|
       Mail::Address.new m
-        rescue Mail::Field::IncompleteParseError
-          nil
-    end.compact
-
-    i.select do |m|
+    rescue Mail::Field::IncompleteParseError
+      nil
+    end.compact.select do |m|
       m.local && m.domain
-    end
+    end.map(&:address)
   end
 
   # El tipo de invitación que tenemos que enviar, si alguien mandó
   # cualquier cosa, usamos el privilegio menor.
+  #
+  # @return [String]
   def invited_as
-    if Rol::ROLES.include?(params[:invited_as])
-      params[:invited_as]
-    else
-      'invitade'
-    end
+    Rol.role?(params[:invited_as]) ? params[:invited_as] : Rol::INVITADE
+  end
+
+  def invite_as
+    Rol.role?(params[:invite_as]&.singularize) ? params[:invite_as] : Rol::INVITADE.pluralize
+  end
+
+  def site
+    @site ||= find_site
   end
 end

app/helpers/application_helper.rb

@@ -13,7 +13,7 @@ module ApplicationHelper
     root = names.shift
 
     names.each do |n|
-      root += '[' + n.to_s + ']'
+      root += "[#{n}]"
     end
 
     [root, name]
@@ -22,7 +22,7 @@ module ApplicationHelper
   def plain_field_name_for(*names)
     root, name = field_name_for(*names)
 
-    root + '[' + name.to_s + ']'
+    "#{root}[#{name}]"
   end
 
   def distance_of_time_in_words_if_more_than_a_minute(seconds)
@@ -33,10 +33,24 @@ module ApplicationHelper
     end
   end
 
-  # Devuelve todas las etiquetas HTML que queremos mantener
-  def all_html_tags
-    %w[h1 h2 h3 h4 h5 h6 p a ul ol li table tr td th tbody thead
-       tfoot em strong sup blockquote cite pre section article]
+  # Sanitizador que elimina todo
+  #
+  # @param html [String]
+  # @return [String]
+  def text_plain(html)
+    sanitize(html, tags: [], attributes: [])
+  end
+
+  # Sanitizador con etiquetas y atributos por defecto
+  #
+  # @param html [String]
+  # @param options [Hash]
+  # @return [String]
+  def sanitize(html, options = {})
+    options[:tags] ||= Sutty::ALLOWED_TAGS
+    options[:attributes] ||= Sutty::ALLOWED_ATTRIBUTES
+
+    super(html, options)
   end
 
   # Genera HTML y limpia etiquetas innecesarias
@@ -73,11 +87,12 @@ module ApplicationHelper
 
   # Opciones por defecto para el campo de un formulario
   def field_options(attribute, metadata, **extra)
-    required = metadata.required || extra[:required]
+    required = extra.key?(:required) ? extra[:required] : metadata.required
 
     {
       class: "form-control #{invalid(metadata.post, attribute)} #{extra[:class]}",
       required: required,
+      disabled: metadata.disabled?,
       autofocus: (metadata.post.attributes.first == attribute),
       aria: {
         describedby: id_for_help(attribute),
@@ -92,10 +107,11 @@ module ApplicationHelper
   end
 
   # Busca la traducción de una etiqueta en los metadatos de un post
-  def post_label_t(*attribute, post:)
-    label = post_t(*attribute, post: post, type: :label)
+  def post_label_t(*attribute, post:, **extra)
+    required = extra.key?(:required) ? extra[:required] : post[attribute.first].required
 
-    label += I18n.t('posts.attributes.required.label') if post.send(attribute.first).required
+    label = post_t(*attribute, post: post, type: :label)
+    label += I18n.t('posts.attributes.required.label') if required
 
     label
   end
@@ -116,16 +132,11 @@ module ApplicationHelper
     "#{attribute.join('-')}-datalist"
   end
 
-  def local_channel
-    "sutty-#{I18n.locale}"
-  end
-
   private
 
   def post_t(*attribute, post:, type:)
     post.layout.metadata.dig(*attribute, type.to_s, I18n.locale.to_s) ||
-      post.layout.metadata.dig(*attribute,
-                               type.to_s, I18n.default_locale.to_s) ||
+      post.layout.metadata.dig(*attribute, type.to_s, I18n.default_locale.to_s) ||
       I18n.t("posts.attributes.#{attribute.join('.')}.#{type}")
   end
 end

app/helpers/moderation_queue_helper.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module ModerationQueueHelper
+  def filter_states(**args)
+    params.permit(:instance_state, :actor_state, :activity_pub_state).merge(**args)
+  end
+
+  def active?(states, state_name, state)
+    if params[state_name].present?
+      params[state_name] == state.to_s
+    else
+      states.first == state
+    end
+  end
+end

app/javascript/controllers/details_controller.js

@@ -0,0 +1,17 @@
+import { Controller } from "stimulus";
+
+export default class extends Controller {
+  static targets = [];
+
+  connect() {
+    const state = window.sessionStorage.getItem(this.element.id);
+
+    if (state === "open") {
+      this.element.setAttribute("open", true);
+    }
+  }
+
+  store(event = undefined) {
+    window.sessionStorage.setItem(this.element.id, event.newState);
+  }
+}

app/javascript/controllers/dropdown_controller.js

@@ -0,0 +1,106 @@
+import { Controller } from "stimulus";
+
+// https://getbootstrap.com/docs/4.6/components/dropdowns/#single-button
+export default class extends Controller {
+  static targets = ["dropdown", "button", "item"];
+
+  // Al iniciar el controlador
+  connect() {
+    // Llevar la cuenta del item con foco
+    this.data.set("item", -1);
+
+    // Gestionar las teclas
+    this.keydownEvent = this.keydown.bind(this);
+    this.element.addEventListener("keydown", this.keydownEvent);
+
+    // Gestionar el foco
+    this.focusinEvent = this.focusin.bind(this);
+  }
+
+  // Al eliminar el controlador (al pasar a otra página)
+  disconnect() {
+    // Eliminar la gestión de teclas
+    this.element.removeEventListener("keydown", this.keydownEvent);
+    // Eliminar la gestión del foco
+    document.removeEventListener("focusin", this.focusinEvent);
+  }
+
+  // Mostrar u ocultar
+  toggle(event) {
+    (this.buttonTarget.ariaExpanded === "false") ? this.show() : this.hide();
+  }
+
+  // Mostrar
+  show() {
+    this.buttonTarget.ariaExpanded = "true";
+    this.element.classList.add("show");
+    this.dropdownTarget.classList.add("show");
+
+    // Activar la gestión del foco
+    document.addEventListener("focusin", this.focusinEvent);
+  }
+
+  // Ocultar
+  hide() {
+    this.buttonTarget.ariaExpanded = "false";
+    this.element.classList.remove("show");
+    this.dropdownTarget.classList.remove("show");
+    // Volver al inicio el foco de items
+    this.data.set("item", -1);
+
+    // Desactivar la gestión del foco
+    document.removeEventListener("focusin", this.focusinEvent);
+  }
+
+  // Gestionar el foco
+  focusin(event) {
+    const item = this.itemTargets.find(x => x === event.target);
+
+    // Si el foco se coloca sobre elementos del controlador, no hacer
+    // nada
+    if (event.target === this.buttonTarget || item) {
+      // Si es un item, el comportamiento de las flechas verticales y el
+      // Tab tiene que ser igual
+      if (item) this.data.set("item", this.itemTargets.indexOf(item));
+
+      return;
+    }
+
+    // De lo contrario, ocultar
+    this.hide();
+  }
+
+  // Gestionar las teclas
+  keydown(event) {
+    const initial = parseInt(this.data.get("item"));
+    let item = initial;
+
+    switch (event.keyCode) {
+      case 27:
+        // Esc cierra el menú y devuelve el foco
+        this.hide();
+        this.buttonTarget.focus();
+        break;
+      case 38:
+        // Moverse hacia arriba con tope en el primer item
+        if (item > -1) item--;
+
+        break;
+      case 40:
+        // Moverse hacia abajo con tope en el último ítem, si el
+        // dropdown estaba cerrado, abrirlo.
+        if (item === -1) this.show();
+        if (item <= this.itemTargets.length) item++;
+
+        break;
+    }
+
+    // Si cambió la posición del ítem, darle foco y actualizar el
+    // contador.
+    if (initial !== item) {
+      this.itemTargets[item]?.focus();
+
+      this.data.set("item", item);
+    }
+  }
+}

app/javascript/controllers/file_preview_controller.js

@@ -0,0 +1,19 @@
+import { Controller } from 'stimulus'
+import bsCustomFileInput from "bs-custom-file-input";
+
+document.addEventListener("turbolinks:load", () => {
+  bsCustomFileInput.init();
+});
+
+export default class extends Controller {
+  static targets = ["preview", "input"];
+
+  connect() {
+  }
+
+  update(event = undefined) {
+    if (!this.hasPreviewTarget) return;
+
+    this.previewTarget.src = window.URL.createObjectURL(this.inputTarget.files[0])
+  }
+}

app/javascript/controllers/non_geo_controller.js

@@ -0,0 +1,81 @@
+import { Controller } from 'stimulus'
+
+require("leaflet/dist/leaflet.css")
+import L from 'leaflet'
+delete L.Icon.Default.prototype._getIconUrl
+
+L.Icon.Default.mergeOptions({
+  iconRetinaUrl: require('leaflet/dist/images/marker-icon-2x.png'),
+  iconUrl: require('leaflet/dist/images/marker-icon.png'),
+  shadowUrl: require('leaflet/dist/images/marker-shadow.png'),
+})
+
+export default class extends Controller {
+  static targets = [ 'lat', 'lng', 'map', 'overlay' ]
+
+  async connect () {
+    this.marker()
+
+    this.latTarget.addEventListener('change', event => this.marker())
+    this.lngTarget.addEventListener('change', event => this.marker())
+    window.addEventListener('resize', event => this.map.invalidateSize())
+
+    this.map.on('click', event => {
+      this.latTarget.value = event.latlng.lat
+      this.lngTarget.value = event.latlng.lng
+
+      this.latTarget.dispatchEvent(new Event('change'))
+    })
+  }
+
+  marker () {
+    if (this._marker) this.map.removeLayer(this._marker)
+
+    this._marker = L.marker(this.coords).addTo(this.map)
+
+    return this._marker
+  }
+
+  get lat () {
+    const lat = parseFloat(this.latTarget.value)
+
+    return isNaN(lat) ? 0 : lat
+  }
+
+  get lng () {
+    const lng = parseFloat(this.lngTarget.value)
+
+    return isNaN(lng) ? 0 : lng
+  }
+
+  get coords () {
+    return [this.lat, this.lng]
+  }
+
+  get bounds () {
+    return [
+      [0, 0],
+      [
+        this.svgOverlay.viewBox.baseVal.height,
+        this.svgOverlay.viewBox.baseVal.width,
+      ]
+    ];
+  }
+
+  get map () {
+    if (!this._map) {
+      this._map = L.map(this.mapTarget, {
+        minZoom: 0,
+        maxZoom: 5
+      }).setView(this.coords, 0);
+
+      this._layer = L.tileLayer(`${this.element.dataset.site}public/map/{z}/{y}/{x}.png`, {
+        minNativeZoom: 0,
+        maxNativeZoom: 5,
+        noWrap: true
+      }).addTo(this._map);
+    }
+
+    return this._map
+  }
+}

app/javascript/controllers/reorder_controller.js

@@ -103,7 +103,7 @@ export default class extends Controller {
     this.reorder()
 
     // Mantenemos el primero a la vista
-    rows[0].row.scrollIntoViewIfNeeded()
+    rows[0].row.scrollIntoView({ block: "center" });
   }
 
   counter () {
@@ -142,7 +142,7 @@ export default class extends Controller {
     this.reorder()
 
     // Mantenemos el primero a la vista
-    rows[0].row.scrollIntoViewIfNeeded()
+    rows[0].row.scrollIntoView({ block: "center" });
   }
 
   bottom (event) {
@@ -163,7 +163,7 @@ export default class extends Controller {
     this.reorder()
 
     // Mantenemos el primero a la vista
-    rows[0].row.scrollIntoViewIfNeeded()
+    rows[0].row.scrollIntoView({ block: "center" });
   }
 
   /*

app/javascript/controllers/select_all_controller.js

@@ -0,0 +1,11 @@
+import { Controller } from "stimulus";
+
+export default class extends Controller {
+  static targets = ["toggle", "input"];
+
+  toggle(event = undefined) {
+    this.inputTargets.forEach(input => {
+      input.checked = this.toggleTarget.checked;
+    });
+  }
+}

app/javascript/editor/editor.ts

@@ -0,0 +1,339 @@
+import { storeContent, restoreContent, forgetContent } from "editor/storage";
+import {
+  isDirectChild,
+  moveChildren,
+  safeGetSelection,
+  safeGetRangeAt,
+  setAuxiliaryToolbar,
+  parentBlockNames,
+  clearSelected,
+} from "editor/utils";
+import { types, getValidChildren, getType } from "editor/types";
+import { setupButtons as setupMarksButtons } from "editor/types/marks";
+import { setupButtons as setupBlocksButtons } from "editor/types/blocks";
+import { setupButtons as setupParentBlocksButtons } from "editor/types/parentBlocks";
+import { setupAuxiliaryToolbar as setupLinkAuxiliaryToolbar } from "editor/types/link";
+import {
+  setupAuxiliaryToolbar as setupMultimediaAuxiliaryToolbar,
+  setupButtons as setupMultimediaButtons,
+} from "editor/types/multimedia";
+import { setupAuxiliaryToolbar as setupMarkAuxiliaryToolbar } from "editor/types/mark";
+
+// Esta funcion corrije errores que pueden haber como:
+//  * que un nodo que no tiene 'text' permitido no tenga children (se les
+//    inserta un allowedChildren[0])
+//  * TODO: que haya una imágen sin <figure> o que no esté como bloque (se ponen
+//    después del bloque en el que están como bloque de por si)
+//  * convierte <i> y <b> en <em> y <strong>
+// Lo hace para que siga la estructura del documento y que no se borren por
+// cleanContent luego.
+function fixContent(editor: Editor, node: Element = editor.contentEl): void {
+  if (node.tagName === "SCRIPT" || node.tagName === "STYLE") {
+    node.parentElement?.removeChild(node);
+    return;
+  }
+
+  if (node.tagName === "I") {
+    const el = document.createElement("em");
+    moveChildren(node, el, null);
+    node.parentElement?.replaceChild(el, node);
+    node = el;
+  }
+  if (node.tagName === "B") {
+    const el = document.createElement("strong");
+    moveChildren(node, el, null);
+    node.parentElement?.replaceChild(el, node);
+    node = el;
+  }
+
+  if (node instanceof HTMLImageElement) {
+    node.dataset.multimediaInner = "";
+    const figureEl = types.multimedia.create(editor);
+
+    let targetEl = node.parentElement;
+    if (!targetEl) throw new Error("No encontré lx objetivo");
+    while (true) {
+      const type = getType(targetEl);
+      if (!type) throw new Error("lx objetivo tiene tipo");
+      if (type.type.allowedChildren.includes("multimedia")) break;
+      if (!targetEl.parentElement) throw new Error("No encontré lx objetivo");
+      targetEl = targetEl.parentElement;
+    }
+
+    let parentEl = [...targetEl.childNodes].find((el) => el.contains(node));
+    if (!parentEl) throw new Error("no encontré lx pariente");
+    targetEl.insertBefore(figureEl, parentEl);
+
+    const innerEl = figureEl.querySelector("[data-multimedia-inner]");
+    if (!innerEl) throw new Error("Raro.");
+    figureEl.replaceChild(node, innerEl);
+
+    node = figureEl;
+  }
+
+  const _type = getType(node);
+  if (!_type) return;
+
+  const { typeName, type } = _type;
+
+  if (type.allowedChildren !== "ignore-children") {
+    const sel = safeGetSelection(editor);
+    const range = sel && safeGetRangeAt(sel);
+
+    if (getValidChildren(node, type).length == 0) {
+      if (typeof type.handleEmpty !== "string") {
+        const el = type.handleEmpty.create(editor);
+        // mover cosas que pueden haber
+        // por ejemplo: cuando convertís a un <ul>, queda texto fuera del li que
+        // creamos acá
+        moveChildren(node, el, null);
+        node.appendChild(el);
+        if (range?.intersectsNode(node)) sel?.collapse(el);
+      }
+    }
+
+    for (const child of node.childNodes) {
+      if (!(child instanceof Element)) continue;
+      fixContent(editor, child);
+    }
+  }
+}
+
+// Esta funcion hace que los elementos del editor sigan la estructura.
+// TODO: nos falta borrar atributos (style, y básicamente cualquier otra cosa)
+// Edge cases:
+//  * no borramos los <br> por que se requieren para que los navegadores
+//    funcionen bien al escribir. no se deberían mostrar de todas maneras
+function cleanContent(editor: Editor, node: Element = editor.contentEl): void {
+  const _type = getType(node);
+  if (!_type) {
+    node.parentElement?.removeChild(node);
+    return;
+  }
+
+  const { type } = _type;
+
+  if (type.allowedChildren !== "ignore-children") {
+    for (const child of node.childNodes) {
+      if (
+        child.nodeType === Node.TEXT_NODE &&
+        !type.allowedChildren.includes("text")
+      ) {
+        node.removeChild(child);
+        continue;
+      }
+
+      if (!(child instanceof Element)) continue;
+
+      const childType = getType(child);
+      if (childType?.typeName === "br") continue;
+      if (!childType || !type.allowedChildren.includes(childType.typeName)) {
+        // XXX: esto extrae las cosas de adentro para que no sea destructivo
+        moveChildren(child, node, child);
+        node.removeChild(child);
+        return;
+      }
+
+      cleanContent(editor, child);
+    }
+
+    // solo contar children válido para ese nodo
+    const validChildrenLength = getValidChildren(node, type).length;
+
+    const sel = safeGetSelection(editor);
+    const range = sel && safeGetRangeAt(sel);
+    if (
+      type.handleEmpty === "remove" &&
+      validChildrenLength == 0
+      //&& (!range || !range.intersectsNode(node))
+    ) {
+      node.parentNode?.removeChild(node);
+      return;
+    }
+  }
+}
+
+function routine(editor: Editor): void {
+  try {
+    fixContent(editor);
+    cleanContent(editor);
+    storeContent(editor);
+
+    editor.htmlEl.value = editor.contentEl.innerHTML;
+  } catch (error) {
+    console.error("Hubo un problema corriendo la rutina", editor, error);
+  }
+}
+
+export interface Editor {
+  editorEl: HTMLElement;
+  toolbarEl: HTMLElement;
+  toolbar: {
+    auxiliary: {
+      mark: {
+        parentEl: HTMLElement;
+        colorEl: HTMLInputElement;
+        textColorEl: HTMLInputElement;
+      };
+      multimedia: {
+        parentEl: HTMLElement;
+        fileEl: HTMLInputElement;
+        uploadEl: HTMLButtonElement;
+        altEl: HTMLInputElement;
+        removeEl: HTMLButtonElement;
+      };
+      link: {
+        parentEl: HTMLElement;
+        urlEl: HTMLInputElement;
+      };
+    };
+  };
+  contentEl: HTMLElement;
+  wordAlertEl: HTMLElement;
+  htmlEl: HTMLTextAreaElement;
+}
+
+function getSel<T extends Element>(parentEl: HTMLElement, selector: string): T {
+  const el = parentEl.querySelector<T>(selector);
+  if (!el) throw new Error(`No pude encontrar un componente \`${selector}\``);
+  return el;
+}
+
+function setupEditor(editorEl: HTMLElement): void {
+  // XXX: ¡Esto afecta a todo el documento! ¿Quizás usar un iframe para el editor?
+  document.execCommand("defaultParagraphSeparator", false, "p");
+
+  const editor: Editor = {
+    editorEl,
+    toolbarEl: getSel(editorEl, ".editor-toolbar"),
+    toolbar: {
+      auxiliary: {
+        mark: {
+          parentEl: getSel(editorEl, "[data-editor-auxiliary=mark]"),
+          colorEl: getSel(
+            editorEl,
+            "[data-editor-auxiliary=mark] [name=mark-color]"
+          ),
+          textColorEl: getSel(
+            editorEl,
+            "[data-editor-auxiliary=mark] [name=mark-text-color]"
+          ),
+        },
+        multimedia: {
+          parentEl: getSel(editorEl, "[data-editor-auxiliary=multimedia]"),
+          fileEl: getSel(
+            editorEl,
+            "[data-editor-auxiliary=multimedia] [name=multimedia-file]"
+          ),
+          uploadEl: getSel(
+            editorEl,
+            "[data-editor-auxiliary=multimedia] [name=multimedia-file-upload]"
+          ),
+          altEl: getSel(
+            editorEl,
+            "[data-editor-auxiliary=multimedia] [name=multimedia-alt]"
+          ),
+          removeEl: getSel(
+            editorEl,
+            "[data-editor-auxiliary=multimedia] [name=multimedia-remove]"
+          ),
+        },
+        link: {
+          parentEl: getSel(editorEl, "[data-editor-auxiliary=link]"),
+          urlEl: getSel(
+            editorEl,
+            "[data-editor-auxiliary=link] [name=link-url]"
+          ),
+        },
+      },
+    },
+    contentEl: getSel(editorEl, ".editor-content"),
+    wordAlertEl: getSel(editorEl, ".editor-aviso-word"),
+    htmlEl: getSel(editorEl, "textarea"),
+  };
+  console.debug("iniciando editor", editor);
+
+  // Recuperar el contenido si hay algo guardado, si tuviéramos un campo
+  // de última edición podríamos saber si el artículo fue editado
+  // después o la versión local es la última.
+  //
+  // TODO: Preguntar si se lo quiere recuperar.
+  restoreContent(editor);
+
+  // Word alert
+  editor.contentEl.addEventListener("paste", () => {
+    editor.wordAlertEl.style.display = "block";
+  });
+
+  // Setup routine listeners
+  const observer = new MutationObserver(() => routine(editor));
+  observer.observe(editor.contentEl, {
+    childList: true,
+    attributes: true,
+    subtree: true,
+    characterData: true,
+  });
+
+  document.addEventListener("selectionchange", () => routine(editor));
+
+  // Capture onClick
+  editor.contentEl.addEventListener(
+    "click",
+    (event) => {
+      const target = event.target! as Element;
+      const type = getType(target);
+      if (!type || !type.type.onClick) {
+        setAuxiliaryToolbar(editor, null);
+        clearSelected(editor);
+        return true;
+      }
+      type.type.onClick(editor, target);
+      return false;
+    },
+    true
+  );
+
+  // Clean seleted
+  const selectedEl = editor.contentEl.querySelector("[data-editor-selected]");
+  if (selectedEl) delete (selectedEl as HTMLElement).dataset.editorSelected;
+
+  // Setup botones
+  setupMarksButtons(editor);
+  setupBlocksButtons(editor);
+  setupParentBlocksButtons(editor);
+  setupMultimediaButtons(editor);
+
+  setupLinkAuxiliaryToolbar(editor);
+  setupMultimediaAuxiliaryToolbar(editor);
+  setupMarkAuxiliaryToolbar(editor);
+
+  // Finally...
+  routine(editor);
+}
+
+document.addEventListener("turbolinks:load", () => {
+  const flash = document.querySelector<HTMLElement>(".js-flash");
+
+  if (flash) {
+    const keys = JSON.parse(flash.dataset.keys || "[]");
+
+    switch (flash.dataset.target) {
+      case "editor":
+        switch (flash.dataset.action) {
+          case "forget-content":
+            keys.forEach(forgetContent);
+        }
+    }
+  }
+
+  for (const editorEl of document.querySelectorAll<HTMLElement>(
+    ".editor[data-editor]"
+  )) {
+    try {
+      setupEditor(editorEl);
+    } catch (error) {
+      // TODO: mostrar error
+      console.error("no se pudo iniciar el editor, error completo", error);
+    }
+  }
+});

app/javascript/editor/storage.ts

@@ -0,0 +1,38 @@
+import { Editor } from "editor/editor";
+
+/*
+ * Guarda una copia local de los cambios para poder recuperarlos
+ * después.
+ *
+ * Usamos la URL completa sin anchors.
+ */
+function getStorageKey(editor: Editor): string {
+  const keyEl = editor.editorEl.querySelector<HTMLInputElement>(
+    '[data-target="storage-key"]'
+  );
+  if (!keyEl)
+    throw new Error("No encuentro la llave para guardar los artículos");
+  return keyEl.value;
+}
+
+export function forgetContent(storedKey: string): void {
+  window.localStorage.removeItem(storedKey);
+}
+
+export function storeContent(editor: Editor): void {
+  if (editor.contentEl.innerText.trim().length === 0) return;
+
+  window.localStorage.setItem(
+    getStorageKey(editor),
+    editor.contentEl.innerHTML
+  );
+}
+
+export function restoreContent(editor: Editor): void {
+  const content = window.localStorage.getItem(getStorageKey(editor));
+
+  if (!content) return;
+  if (content.trim().length === 0) return;
+
+  editor.contentEl.innerHTML = content;
+}

app/javascript/editor/types.ts

@@ -0,0 +1,140 @@
+import { Editor } from "editor/editor";
+import { marks } from "editor/types/marks";
+import { blocks, li, EditorBlock } from "editor/types/blocks";
+import { parentBlocks } from "editor/types/parentBlocks";
+import { multimedia } from "editor/types/multimedia";
+import {
+  blockNames,
+  parentBlockNames,
+  safeGetRangeAt,
+  safeGetSelection,
+} from "editor/utils";
+
+export interface EditorNode {
+  selector: string;
+  // la string es el nombre en la gran lista de types O 'text'
+  // XXX: esto es un hack para no poner EditorNode dentro de EditorNode,
+  // quizás podemos hacer que esto sea una función que retorna bool
+  allowedChildren: string[] | "ignore-children";
+
+  // * si es 'do-nothing', no hace nada si está vacío (esto es para cuando
+  //   permitís 'text' entonces se puede tipear adentro, ej: párrafo vacío)
+  // * si es 'remove', sacamos el coso si está vacío.
+  //   ej: strong: { handleNothing: 'remove' }
+  // * si es un block, insertamos el bloque y movemos la selección ahí
+  //   ej: ul: { handleNothing: li }
+  handleEmpty: "do-nothing" | "remove" | EditorBlock;
+
+  // esta función puede ser llamada para cosas que no necesariamente sea la
+  // creación del nodo con el botón; por ejemplo, al intentar recuperar
+  // el formato. esto es importante por que, por ejemplo, no deberíamos
+  // cambiar la selección acá.
+  create: (editor: Editor) => HTMLElement;
+
+  onClick?: (editor: Editor, target: Element) => void;
+}
+
+export const types: { [propName: string]: EditorNode } = {
+  ...marks,
+  ...blocks,
+  li,
+  ...parentBlocks,
+  contentEl: {
+    selector: ".editor-content",
+    allowedChildren: [...blockNames, ...parentBlockNames, "multimedia"],
+    handleEmpty: blocks.paragraph,
+    create: () => {
+      throw new Error("se intentó crear contentEl");
+    },
+  },
+  br: {
+    selector: "br",
+    allowedChildren: [],
+    handleEmpty: "do-nothing",
+    create: () => {
+      throw new Error("se intentó crear br");
+    },
+  },
+  multimedia,
+};
+
+export function getType(
+  node: Element
+): { typeName: string; type: EditorNode } | null {
+  for (let [typeName, type] of Object.entries(types)) {
+    if (node.matches(type.selector)) {
+      return { typeName, type };
+    }
+  }
+
+  return null;
+}
+
+// encuentra el primer pariente que pueda tener al type, y retorna un array
+// donde
+//   array[0] = elemento que matchea el type
+//   array[array.len - 1] = primer elemento seleccionado
+export function getValidParentInSelection(args: {
+  editor: Editor;
+  type: string;
+}): Element[] {
+  const sel = safeGetSelection(args.editor);
+  if (!sel) throw new Error("No se donde insertar esto");
+  const range = safeGetRangeAt(sel);
+  if (!range) throw new Error("No se donde insertar esto");
+
+  let list: Element[] = [];
+
+  if (!sel.anchorNode) {
+    throw new Error("No se donde insertar esto");
+  } else if (sel.anchorNode instanceof Element) {
+    list = [sel.anchorNode];
+  } else if (sel.anchorNode.parentElement) {
+    list = [sel.anchorNode.parentElement];
+  } else {
+    throw new Error("No se donde insertar esto");
+  }
+
+  while (true) {
+    const el = list[0];
+    if (!args.editor.contentEl.contains(el) && el != args.editor.contentEl)
+      throw new Error("No se donde insertar esto");
+    const type = getType(el);
+
+    if (type) {
+      //if (type.typeName === 'contentEl') break
+      //if (parentBlockNames.includes(type.typeName)) break
+      if (
+        type.type.allowedChildren instanceof Array &&
+        type.type.allowedChildren.includes(args.type)
+      )
+        break;
+    }
+    if (el.parentElement) {
+      list = [el.parentElement, ...list];
+    } else {
+      throw new Error("No se donde insertar esto");
+    }
+  }
+
+  return list;
+}
+
+export function getValidChildren(node: Element, type: EditorNode): Node[] {
+  if (type.allowedChildren === "ignore-children")
+    throw new Error(
+      "se llamó a getValidChildren con un type que no lo permite!"
+    );
+  return [...node.childNodes].filter((n) => {
+    // si permite texto y esto es un texto, es válido
+    if (n.nodeType === Node.TEXT_NODE)
+      return type.allowedChildren.includes("text") && n.textContent?.length;
+
+    // si no es un elemento, no es válido
+    if (!(n instanceof Element)) return false;
+
+    const t = getType(n);
+    if (!t) return false;
+    return type.allowedChildren.includes(t.typeName);
+  });
+}

app/javascript/editor/types/blocks.ts

@@ -0,0 +1,82 @@
+import { Editor } from "editor/editor";
+import {
+  safeGetSelection,
+  safeGetRangeAt,
+  moveChildren,
+  markNames,
+  blockNames,
+  parentBlockNames,
+} from "editor/utils";
+import { EditorNode, getType, getValidParentInSelection } from "editor/types";
+
+export interface EditorBlock extends EditorNode {}
+
+function makeBlock(tag: string): EditorBlock {
+  return {
+    selector: tag,
+    allowedChildren: [...markNames, "text"],
+    handleEmpty: "do-nothing",
+    create: () => document.createElement(tag),
+  };
+}
+
+export const li: EditorBlock = makeBlock("li");
+const paragraph: EditorBlock = makeBlock("p");
+
+// XXX: si agregás algo acá, agregalo a blockNames
+// (y probablemente le quieras hacer un botón en app/views/posts/attributes/_content.haml)
+export const blocks: { [propName: string]: EditorBlock } = {
+  paragraph,
+  h1: makeBlock("h1"),
+  h2: makeBlock("h2"),
+  h3: makeBlock("h3"),
+  h4: makeBlock("h4"),
+  h5: makeBlock("h5"),
+  h6: makeBlock("h6"),
+  unordered_list: {
+    ...makeBlock("ul"),
+    allowedChildren: ["li"],
+    handleEmpty: li,
+  },
+  ordered_list: {
+    ...makeBlock("ol"),
+    allowedChildren: ["li"],
+    handleEmpty: li,
+  },
+  blockquote: {
+    ...makeBlock("blockquote"),
+    allowedChildren: blockNames,
+    handleEmpty: paragraph,
+  },
+};
+
+export function setupButtons(editor: Editor): void {
+  for (const [name, type] of Object.entries(blocks)) {
+    const buttonEl = editor.toolbarEl.querySelector(
+      `[data-editor-button="block-${name}"]`
+    );
+    if (!buttonEl) continue;
+    buttonEl.addEventListener("click", (event) => {
+      event.preventDefault();
+
+      const list = getValidParentInSelection({ editor, type: name });
+
+      // No borrar cosas como multimedia
+      if (blockNames.indexOf(getType(list[1])!.typeName) === -1) {
+        return;
+      }
+
+      let replacementType = list[1].matches(type.selector)
+        ? blocks.paragraph
+        : type;
+
+      const el = replacementType.create(editor);
+      replacementType.onClick && replacementType.onClick(editor, el);
+      moveChildren(list[1], el, null);
+      list[0].replaceChild(el, list[1]);
+      window.getSelection()?.collapse(el);
+
+      return false;
+    });
+  }
+}

app/javascript/editor/types/link.ts

@@ -0,0 +1,37 @@
+import { Editor } from "editor/editor";
+import { EditorNode } from "editor/types";
+import { markNames, setAuxiliaryToolbar, clearSelected } from "editor/utils";
+
+function select(editor: Editor, el: HTMLAnchorElement): void {
+  clearSelected(editor);
+  el.dataset.editorSelected = "";
+  editor.toolbar.auxiliary.link.urlEl.value = el.href;
+  setAuxiliaryToolbar(editor, editor.toolbar.auxiliary.link.parentEl);
+}
+
+export const link: EditorNode = {
+  selector: "a",
+  allowedChildren: [...markNames.filter((n) => n !== "link"), "text"],
+  handleEmpty: "remove",
+  create: () => document.createElement("a"),
+  onClick(editor, el) {
+    if (!(el instanceof HTMLAnchorElement)) throw new Error("oh no");
+    select(editor, el);
+  },
+};
+
+export function setupAuxiliaryToolbar(editor: Editor): void {
+  editor.toolbar.auxiliary.link.urlEl.addEventListener("input", (event) => {
+    const url = editor.toolbar.auxiliary.link.urlEl.value;
+    const selectedEl = editor.contentEl.querySelector<HTMLAnchorElement>(
+      "a[data-editor-selected]"
+    );
+    if (!selectedEl)
+      throw new Error("No pude encontrar el link para setear el enlace");
+
+    selectedEl.href = url;
+  });
+  editor.toolbar.auxiliary.link.urlEl.addEventListener("keydown", (event) => {
+    if (event.keyCode == 13) event.preventDefault();
+  });
+}

app/javascript/editor/types/mark.ts

@@ -0,0 +1,66 @@
+import { Editor } from "editor/editor";
+import { EditorNode } from "editor/types";
+import { markNames, setAuxiliaryToolbar, clearSelected } from "editor/utils";
+
+const hex = (x: string) => ("0" + parseInt(x).toString(16)).slice(-2);
+// https://stackoverflow.com/a/3627747
+// TODO: cambiar por una solución más copada
+function rgbToHex(rgb: string): string {
+  const matches = rgb.match(/^rgb\((\d+),\s*(\d+),\s*(\d+)\)$/);
+  if (!matches) throw new Error("no pude parsear el rgb()");
+  return "#" + hex(matches[1]) + hex(matches[2]) + hex(matches[3]);
+}
+
+function select(editor: Editor, el: HTMLElement): void {
+  clearSelected(editor);
+  el.dataset.editorSelected = "";
+  editor.toolbar.auxiliary.mark.colorEl.value = el.style.backgroundColor
+    ? rgbToHex(el.style.backgroundColor)
+    : "#f206f9";
+  editor.toolbar.auxiliary.mark.textColorEl.value = el.style.color
+    ? rgbToHex(el.style.color)
+    : "#000000";
+  setAuxiliaryToolbar(editor, editor.toolbar.auxiliary.mark.parentEl);
+}
+
+export const mark: EditorNode = {
+  selector: "mark",
+  allowedChildren: [...markNames.filter((n) => n !== "mark"), "text"],
+  handleEmpty: "remove",
+  create: () => document.createElement("mark"),
+  onClick(editor, el) {
+    if (!(el instanceof HTMLElement)) throw new Error("oh no");
+    select(editor, el);
+  },
+};
+
+export function setupAuxiliaryToolbar(editor: Editor): void {
+  editor.toolbar.auxiliary.mark.colorEl.addEventListener("input", (event) => {
+    const color = editor.toolbar.auxiliary.mark.colorEl.value;
+    const selectedEl = editor.contentEl.querySelector<HTMLElement>(
+      "mark[data-editor-selected]"
+    );
+    if (!selectedEl)
+      throw new Error("No pude encontrar el mark para setear el color");
+
+    selectedEl.style.backgroundColor = color;
+  });
+  editor.toolbar.auxiliary.mark.textColorEl.addEventListener(
+    "input",
+    (event) => {
+      const color = editor.toolbar.auxiliary.mark.textColorEl.value;
+      const selectedEl = editor.contentEl.querySelector<HTMLElement>(
+        "mark[data-editor-selected]"
+      );
+      if (!selectedEl)
+        throw new Error(
+          "No pude encontrar el mark para setear el color del text"
+        );
+
+      selectedEl.style.color = color;
+    }
+  );
+  editor.toolbar.auxiliary.mark.colorEl.addEventListener("keydown", (event) => {
+    if (event.keyCode == 13) event.preventDefault();
+  });
+}

app/javascript/editor/types/marks.ts

@@ -0,0 +1,102 @@
+import { Editor } from "editor/editor";
+import { EditorNode } from "editor/types";
+import {
+  safeGetSelection,
+  safeGetRangeAt,
+  moveChildren,
+  markNames,
+} from "editor/utils";
+import { link } from "editor/types/link";
+import { mark } from "editor/types/mark";
+
+function makeMark(name: string, tag: string): EditorNode {
+  return {
+    selector: tag,
+    allowedChildren: [...markNames.filter((n) => n !== name), "text"],
+    handleEmpty: "remove",
+    create: () => document.createElement(tag),
+  };
+}
+
+// XXX: si agregás algo acá, agregalo a markNames
+export const marks: { [propName: string]: EditorNode } = {
+  bold: makeMark("bold", "strong"),
+  italic: makeMark("italic", "em"),
+  deleted: makeMark("deleted", "del"),
+  underline: makeMark("underline", "u"),
+  sub: makeMark("sub", "sub"),
+  super: makeMark("super", "sup"),
+  mark,
+  link,
+  small: makeMark("small", "small"),
+};
+
+function recursiveFilterSelection(
+  node: Element,
+  selection: Selection,
+  selector: string
+): Element[] {
+  let output: Element[] = [];
+  for (const child of [...node.children]) {
+    if (child.matches(selector) && selection.containsNode(child))
+      output.push(child);
+    output = [
+      ...output,
+      ...recursiveFilterSelection(child, selection, selector),
+    ];
+  }
+  return output;
+}
+
+export function setupButtons(editor: Editor): void {
+  for (const [name, type] of Object.entries(marks)) {
+    const buttonEl = editor.toolbarEl.querySelector(
+      `[data-editor-button="mark-${name}"]`
+    );
+    if (!buttonEl) continue;
+    buttonEl.addEventListener("click", (event) => {
+      event.preventDefault();
+
+      const sel = safeGetSelection(editor);
+      if (!sel) return;
+      const range = safeGetRangeAt(sel);
+      if (!range) return;
+
+      let parentEl = range.commonAncestorContainer;
+      while (!(parentEl instanceof Element)) {
+        if (!parentEl.parentElement) return;
+        parentEl = parentEl.parentElement;
+      }
+
+      const existingMarks = recursiveFilterSelection(
+        parentEl,
+        sel,
+        type.selector
+      );
+      console.debug("marks encontradas:", existingMarks);
+
+      if (existingMarks.length > 0) {
+        const mark = existingMarks[0];
+        if (!mark.parentElement) throw new Error(":/");
+        moveChildren(mark, mark.parentElement, mark);
+        mark.parentElement.removeChild(mark);
+      } else {
+        if (range.commonAncestorContainer === editor.contentEl)
+          // TODO: mostrar error
+          return console.error(
+            "No puedo marcar cosas a través de distintos bloques!"
+          );
+
+        const tagEl = type.create(editor);
+        type.onClick && type.onClick(editor, tagEl);
+
+        tagEl.appendChild(range.extractContents());
+
+        range.insertNode(tagEl);
+        range.selectNode(tagEl);
+      }
+
+      return false;
+    });
+  }
+}

app/javascript/editor/types/multimedia.ts

@@ -0,0 +1,232 @@
+import * as ActiveStorage from "@rails/activestorage";
+import { Editor } from "editor/editor";
+import { EditorNode, getValidParentInSelection } from "editor/types";
+import {
+  safeGetSelection,
+  safeGetRangeAt,
+  markNames,
+  parentBlockNames,
+  setAuxiliaryToolbar,
+  clearSelected,
+} from "editor/utils";
+
+function uploadFile(file: File): Promise<string> {
+  return new Promise((resolve, reject) => {
+    const upload = new ActiveStorage.DirectUpload(
+      file,
+      origin + "/rails/active_storage/direct_uploads"
+    );
+
+    upload.create((error: any, blob: any) => {
+      if (error) {
+        reject(error);
+      } else {
+        const url = `${origin}/rails/active_storage/blobs/${blob.signed_id}/${blob.filename}`;
+        resolve(url);
+      }
+    });
+  });
+}
+
+function getAlt(multimediaInnerEl: HTMLElement): string | null {
+  switch (multimediaInnerEl.tagName) {
+    case "VIDEO":
+    case "AUDIO":
+      return multimediaInnerEl.getAttribute("aria-label");
+    case "IMG":
+      return (multimediaInnerEl as HTMLImageElement).alt;
+    case "IFRAME":
+      return multimediaInnerEl.title;
+    default:
+      throw new Error("no pude conseguir el alt");
+  }
+}
+function setAlt(multimediaInnerEl: HTMLElement, value: string): void {
+  switch (multimediaInnerEl.tagName) {
+    case "VIDEO":
+    case "AUDIO":
+      multimediaInnerEl.setAttribute("aria-label", value);
+      break;
+    case "IMG":
+      (multimediaInnerEl as HTMLImageElement).alt = value;
+      break;
+    case "IFRAME":
+      multimediaInnerEl.title = value;
+      break;
+    default:
+      throw new Error("no pude setear el alt");
+  }
+}
+
+function select(editor: Editor, el: HTMLElement): void {
+  clearSelected(editor);
+  el.dataset.editorSelected = "";
+
+  const innerEl = el.querySelector<HTMLElement>("[data-multimedia-inner]");
+  if (!innerEl) throw new Error("No hay multimedia válida");
+  if (innerEl.tagName === "P") {
+    editor.toolbar.auxiliary.multimedia.altEl.value = "";
+    editor.toolbar.auxiliary.multimedia.altEl.disabled = true;
+  } else {
+    editor.toolbar.auxiliary.multimedia.altEl.value = getAlt(innerEl) || "";
+    editor.toolbar.auxiliary.multimedia.altEl.disabled = false;
+  }
+
+  setAuxiliaryToolbar(editor, editor.toolbar.auxiliary.multimedia.parentEl);
+}
+
+export const multimedia: EditorNode = {
+  selector: "figure[data-multimedia]",
+  allowedChildren: "ignore-children",
+  handleEmpty: "remove",
+  create: () => {
+    const figureEl = document.createElement("figure");
+    figureEl.dataset.multimedia = "";
+    figureEl.contentEditable = "false";
+
+    const placeholderEl = document.createElement("p");
+    placeholderEl.dataset.multimediaInner = "";
+    // TODO i18n
+    placeholderEl.append("¡Clickeame para subir un archivo!");
+    figureEl.appendChild(placeholderEl);
+
+    const descriptionEl = document.createElement("figcaption");
+    descriptionEl.contentEditable = "true";
+    // TODO i18n
+    descriptionEl.append("Escribí acá la descripción del archivo.");
+    figureEl.appendChild(descriptionEl);
+
+    return figureEl;
+  },
+  onClick(editor, el) {
+    if (!(el instanceof HTMLElement)) throw new Error("oh no");
+    select(editor, el);
+  },
+};
+function createElementWithFile(url: string, type: string): HTMLElement {
+  if (type.match(/^image\/.+$/)) {
+    const el = document.createElement("img");
+    el.dataset.multimediaInner = "";
+    el.src = url;
+    return el;
+  } else if (type.match(/^video\/.+$/)) {
+    const el = document.createElement("video");
+    el.controls = true;
+    el.dataset.multimediaInner = "";
+    el.src = url;
+    return el;
+  } else if (type.match(/^audio\/.+$/)) {
+    const el = document.createElement("audio");
+    el.controls = true;
+    el.dataset.multimediaInner = "";
+    el.src = url;
+    return el;
+  } else if (type.match(/^application\/pdf$/)) {
+    const el = document.createElement("iframe");
+    el.dataset.multimediaInner = "";
+    el.src = url;
+    return el;
+  } else {
+    // TODO: chequear si el archivo es válido antes de subir
+    throw new Error("Tipo de archivo no reconocido");
+  }
+}
+
+export function setupAuxiliaryToolbar(editor: Editor): void {
+  editor.toolbar.auxiliary.multimedia.uploadEl.addEventListener(
+    "click",
+    (event) => {
+      const files = editor.toolbar.auxiliary.multimedia.fileEl.files;
+      if (!files || !files.length) {
+        console.info("no hay archivos para subir");
+        return;
+      }
+      const file = files[0];
+
+      const selectedEl = editor.contentEl.querySelector<HTMLElement>(
+        "figure[data-editor-selected]"
+      );
+      if (!selectedEl)
+        throw new Error("No pude encontrar el elemento para setear el archivo");
+
+      selectedEl.dataset.editorLoading = "";
+      uploadFile(file)
+        .then((url) => {
+          const innerEl = selectedEl.querySelector("[data-multimedia-inner]");
+          if (!innerEl) throw new Error("No hay multimedia a reemplazar");
+
+          const el = createElementWithFile(url, file.type);
+          setAlt(el, editor.toolbar.auxiliary.multimedia.altEl.value);
+          selectedEl.replaceChild(el, innerEl);
+
+          select(editor, selectedEl);
+
+          delete selectedEl.dataset.editorError;
+        })
+        .catch((err) => {
+          console.error(err);
+          // TODO: mostrar error
+          selectedEl.dataset.editorError = "";
+        })
+        .finally(() => {
+          delete selectedEl.dataset.editorLoading;
+        });
+    }
+  );
+
+  editor.toolbar.auxiliary.multimedia.removeEl.addEventListener(
+    "click",
+    (event) => {
+      const selectedEl = editor.contentEl.querySelector<HTMLElement>(
+        "figure[data-editor-selected]"
+      );
+      if (!selectedEl)
+        throw new Error("No pude encontrar el elemento para borrar");
+
+      selectedEl.parentElement?.removeChild(selectedEl);
+      setAuxiliaryToolbar(editor, null);
+    }
+  );
+
+  editor.toolbar.auxiliary.multimedia.altEl.addEventListener(
+    "input",
+    (event) => {
+      const selectedEl = editor.contentEl.querySelector<HTMLAnchorElement>(
+        "figure[data-editor-selected]"
+      );
+      if (!selectedEl)
+        throw new Error("No pude encontrar el multimedia para setear el alt");
+
+      const innerEl = selectedEl.querySelector<HTMLElement>(
+        "[data-multimedia-inner]"
+      );
+      if (!innerEl) throw new Error("No hay multimedia a para setear el alt");
+
+      setAlt(innerEl, editor.toolbar.auxiliary.multimedia.altEl.value);
+    }
+  );
+  editor.toolbar.auxiliary.multimedia.altEl.addEventListener(
+    "keydown",
+    (event) => {
+      if (event.keyCode == 13) event.preventDefault();
+    }
+  );
+}
+
+export function setupButtons(editor: Editor): void {
+  const buttonEl = editor.toolbarEl.querySelector(
+    '[data-editor-button="multimedia"]'
+  );
+  if (!buttonEl) throw new Error("No encontre el botón de multimedia");
+  buttonEl.addEventListener("click", (event) => {
+    event.preventDefault();
+
+    const list = getValidParentInSelection({ editor, type: "multimedia" });
+
+    const el = multimedia.create(editor);
+    list[0].insertBefore(el, list[1].nextElementSibling);
+    select(editor, el);
+
+    return false;
+  });
+}

app/javascript/editor/types/parentBlocks.ts

@@ -0,0 +1,77 @@
+import { Editor } from "editor/editor";
+import {
+  safeGetSelection,
+  safeGetRangeAt,
+  moveChildren,
+  blockNames,
+  parentBlockNames,
+} from "editor/utils";
+import { EditorNode, getType, getValidParentInSelection } from "editor/types";
+
+function makeParentBlock(
+  tag: string,
+  create: EditorNode["create"]
+): EditorNode {
+  return {
+    selector: tag,
+    allowedChildren: [...blockNames, "multimedia"],
+    handleEmpty: "remove",
+    create,
+  };
+}
+
+// XXX: si agregás algo acá, probablemente le quieras hacer un botón
+// en app/views/posts/attributes/_content.haml
+export const parentBlocks: { [propName: string]: EditorNode } = {
+  left: makeParentBlock("div[data-align=left]", () => {
+    const el = document.createElement("div");
+    el.dataset.align = "left";
+    el.style.textAlign = "left";
+    return el;
+  }),
+  center: makeParentBlock("div[data-align=center]", () => {
+    const el = document.createElement("div");
+    el.dataset.align = "center";
+    el.style.textAlign = "center";
+    return el;
+  }),
+  right: makeParentBlock("div[data-align=right]", () => {
+    const el = document.createElement("div");
+    el.dataset.align = "right";
+    el.style.textAlign = "right";
+    return el;
+  }),
+};
+
+export function setupButtons(editor: Editor): void {
+  for (const [name, type] of Object.entries(parentBlocks)) {
+    const buttonEl = editor.toolbarEl.querySelector(
+      `[data-editor-button="parentBlock-${name}"]`
+    );
+    if (!buttonEl) continue;
+    buttonEl.addEventListener("click", (event) => {
+      event.preventDefault();
+
+      // TODO: Esto solo mueve el bloque en el que está el final de la selección
+      // (anchorNode). quizás lo podemos hacer al revés (iterar desde contentEl
+      // para encontrar los bloques que están seleccionados y moverlos/cambiarles
+      // el parentBlock)
+
+      const list = getValidParentInSelection({ editor, type: name });
+
+      const replacementEl = type.create(editor);
+      if (list[0] == editor.contentEl) {
+        // no está en un parentBlock
+        editor.contentEl.insertBefore(replacementEl, list[1]);
+        replacementEl.appendChild(list[1]);
+      } else {
+        // está en un parentBlock
+        moveChildren(list[0], replacementEl, null);
+        editor.contentEl.replaceChild(replacementEl, list[0]);
+      }
+      window.getSelection()?.collapse(replacementEl);
+
+      return false;
+    });
+  }
+}

app/javascript/editor/utils.ts

@@ -0,0 +1,102 @@
+import { Editor } from "editor/editor";
+
+export const blockNames = [
+  "paragraph",
+  "h1",
+  "h2",
+  "h3",
+  "h4",
+  "h5",
+  "h6",
+  "unordered_list",
+  "ordered_list",
+  "blockquote",
+];
+export const markNames = [
+  "bold",
+  "italic",
+  "deleted",
+  "underline",
+  "sub",
+  "super",
+  "mark",
+  "link",
+  "small",
+];
+export const parentBlockNames = ["left", "center", "right"];
+
+export function moveChildren(from: Element, to: Element, toRef: Node | null) {
+  while (from.firstChild) to.insertBefore(from.firstChild, toRef);
+}
+
+export function isDirectChild(node: Node, supposedChild: Node): boolean {
+  for (const child of node.childNodes) {
+    if (child == supposedChild) return true;
+  }
+  return false;
+}
+
+export function safeGetSelection(editor: Editor): Selection | null {
+  const sel = window.getSelection();
+  if (!sel) return null;
+  // XXX: no damos la selección si esta fuera o _es_ el contentEl, ¿quizás
+  // deberíamos mostrar un error?
+  if (
+    !editor.contentEl.contains(sel.anchorNode) ||
+    !editor.contentEl.contains(sel.focusNode) ||
+    sel.anchorNode == editor.contentEl ||
+    sel.focusNode == editor.contentEl
+  )
+    return null;
+  return sel;
+}
+
+export function safeGetRangeAt(selection: Selection, num = 0): Range | null {
+  try {
+    return selection.getRangeAt(num);
+  } catch (error) {
+    return null;
+  }
+}
+
+interface SplitNode {
+  range: Range;
+  node: Node;
+}
+
+export function splitNode(node: Element, range: Range): [SplitNode, SplitNode] {
+  const [left, right] = [
+    { range: document.createRange(), node: node.cloneNode(false) },
+    { range: document.createRange(), node: node.cloneNode(false) },
+  ];
+
+  if (node.firstChild) left.range.setStartBefore(node.firstChild);
+  left.range.setEnd(range.startContainer, range.startOffset);
+  left.range.surroundContents(left.node);
+
+  right.range.setStart(range.endContainer, range.endOffset);
+  if (node.lastChild) right.range.setEndAfter(node.lastChild);
+  right.range.surroundContents(right.node);
+
+  if (!node.parentElement)
+    throw new Error("No pude separar los nodos por que no tiene parentNode");
+
+  moveChildren(node, node.parentElement, node);
+  node.parentElement.removeChild(node);
+
+  return [left, right];
+}
+
+export function setAuxiliaryToolbar(
+  editor: Editor,
+  bar: HTMLElement | null
+): void {
+  for (const { parentEl } of Object.values(editor.toolbar.auxiliary)) {
+    delete parentEl.dataset.editorAuxiliaryActive;
+  }
+  if (bar) bar.dataset.editorAuxiliaryActive = "active";
+}
+export function clearSelected(editor: Editor): void {
+  const selectedEl = editor.contentEl.querySelector("[data-editor-selected]");
+  if (selectedEl) delete (selectedEl as HTMLElement).dataset.editorSelected;
+}

app/javascript/etc/htmx_abort.js

@@ -0,0 +1,7 @@
+// Cancela las peticiones pendientes de htmx para todos los elementos al
+// cambiar de página.
+document.addEventListener("turbolinks:click", () => {
+  for (const hx of document.querySelectorAll("[hx-get]")) {
+    window.htmx.trigger(hx, "htmx:abort");
+  }
+});

app/javascript/etc/index.js

@@ -0,0 +1,9 @@
+import './external_links'
+import './input-date'
+import './input-tag'
+import './prosemirror'
+import './timezone'
+import './turbolinks-anchors'
+import './validation'
+import './new_editor'
+import './htmx_abort'

app/javascript/etc/input-date.js

@@ -0,0 +1,11 @@
+// Validar fechas en navegadores que no soportan date, como
+// Webkit/Safari
+document.addEventListener('turbolinks:load', () => {
+  document.querySelectorAll('input[type="date"]').forEach(date => {
+    if (date.type === 'date') return
+
+    date.addEventListener('change', event => {
+      date.setCustomValidity(date.validity.patternMismatch ? date.dataset.patternMismatch : '')
+    })
+  })
+})

app/javascript/etc/input-tag.js

@@ -1,3 +1,6 @@
+import InputTag from 'input-tag/input-tag'
+import InputMap from 'input-map/input-map'
+
 document.addEventListener('turbolinks:load', () => {
   document.querySelectorAll('.taggable').forEach(target => {
     target.innerHTML = ''

app/javascript/etc/new_editor.js

@@ -0,0 +1,14 @@
+import SuttyEditor from "@suttyweb/editor";
+
+import "@suttyweb/editor/dist/style.css";
+
+document.addEventListener("turbolinks:load", () => {
+  document.querySelectorAll(".new-editor").forEach((editorContainer) => {
+    new SuttyEditor({
+      target: editorContainer,
+      props: {
+        textareaEl: editorContainer.querySelector("textarea"),
+      },
+    });
+  });
+});

app/javascript/etc/prosemirror.js

@@ -0,0 +1,29 @@
+import {EditorState} from "prosemirror-state"
+import {EditorView} from "prosemirror-view"
+import {schema, defaultMarkdownParser, defaultMarkdownSerializer} from "prosemirror-markdown"
+import {exampleSetup} from "prosemirror-example-setup"
+
+import "prosemirror-gapcursor/style/gapcursor.css"
+import "prosemirror-menu/style/menu.css"
+import "prosemirror-view/style/prosemirror.css"
+import "prosemirror-example-setup/style/style.css"
+
+document.addEventListener('turbolinks:load', () => {
+  document.querySelectorAll('.markdown-content').forEach(mdc => {
+    let textArea = mdc.querySelector(".content"),
+        editor = mdc.querySelector(".markdown-editor");
+
+    let view = new EditorView(editor, {
+      state: EditorState.create({
+        doc: defaultMarkdownParser.parse(textArea.value),
+        plugins: exampleSetup({schema})
+      })
+    })
+
+    // Guardar los cambios al enviar el formulario y cada 10 segundos
+    textArea.form.addEventListener('submit', e => textArea.value = defaultMarkdownSerializer.serialize(view.state.doc));
+    setInterval(() => textArea.value = defaultMarkdownSerializer.serialize(view.state.doc), 10 * 1000);
+    // Ocultar el area
+    textArea.style.display = 'none'
+  })
+})

app/javascript/etc/timezone.js

@@ -0,0 +1,51 @@
+// Lista de equivalencias entre Date#getTimezoneOffset de JS y
+// MetadataEvent
+const timeZoneOffsets = {
+   '720': '-12:00',
+   '660': '-11:00',
+   '600': '-10:00',
+   '570': '-09:30',
+   '540': '-09:00',
+   '480': '-08:00',
+   '420': '-07:00',
+   '360': '-06:00',
+   '300': '-05:00',
+   '240': '-04:00',
+   '210': '-03:30',
+   '180': '-03:00',
+   '120': '-02:00',
+    '60': '-01:00',
+     '0': '00:00',
+   '-60': '+01:00',
+  '-120': '+02:00',
+  '-180': '+03:00',
+  '-210': '+03:30',
+  '-240': '+04:00',
+  '-270': '+04:30',
+  '-300': '+05:00',
+  '-330': '+05:30',
+  '-345': '+05:45',
+  '-360': '+06:00',
+  '-390': '+06:30',
+  '-420': '+07:00',
+  '-480': '+08:00',
+  '-525': '+08:45',
+  '-540': '+09:00',
+  '-570': '+09:30',
+  '-600': '+10:00',
+  '-630': '+10:30',
+  '-660': '+11:00',
+  '-720': '+12:00',
+  '-765': '+12:45',
+  '-780': '+13:00',
+  '-840': '+14:00'
+};
+
+// Obtiene el huso horario local 
+const timeZoneOffset = timeZoneOffsets[(new Date).getTimezoneOffset().toString()];
+
+document.addEventListener('turbolinks:load', () => {
+  // Aplicar el huso horario descubierto en los campos de evento solo
+  // cuando estamos creando un artículo.
+  document.querySelectorAll('.new .event .zone select').forEach(zone => zone.value = timeZoneOffset);
+})

app/javascript/etc/turbolinks-anchors.js

@@ -0,0 +1,3 @@
+document.addEventListener('turbolinks:load', () => {
+  document.querySelectorAll('a[href^="#"]').forEach(a => a.dataset.turbolinks = false)
+})

app/javascript/etc/validation.js

@@ -1,11 +1,10 @@
 document.addEventListener('turbolinks:load', () => {
   // Al enviar el formulario del artículo, aplicar la validación
   // localmente y actualizar los comentarios para lectores de pantalla.
-  document.querySelectorAll('.submit-post').forEach(submit => {
-    submit.addEventListener('click', event => {
-      const form = submit.closest('form')
-      const invalid_help = form.querySelectorAll('.invalid_help')
-      const sending_help = form.querySelectorAll('.sending_help')
+  document.querySelectorAll('form').forEach(form => {
+    form.addEventListener('submit', event => {
+      const invalid_help = form.querySelectorAll('.invalid-help')
+      const sending_help = form.querySelectorAll('.sending-help')
 
       invalid_help.forEach(i => i.classList.add('d-none'))
       sending_help.forEach(i => i.classList.add('d-none'))

app/javascript/packs/application.js

@@ -1,101 +1,44 @@
 /* eslint no-console:0 */
-// This file is automatically compiled by Webpack, along with any other files
-// present in this directory. You're encouraged to place your actual application logic in
-// a relevant structure within app/javascript and only use these pack files to reference
-// that code so it'll be compiled.
-//
-// To reference this file, add <%= javascript_pack_tag 'application' %> to the appropriate
-// layout file, like app/views/layouts/application.html.erb
 
+import { Notifier } from '@airbrake/browser'
 
-// Uncomment to copy all static images under ../images to the output folder and reference
-// them with the image_pack_tag helper in views (e.g <%= image_pack_tag 'rails.png' %>)
-// or the `imagePath` JavaScript helper below.
-//
-// const images = require.context('../images', true)
-// const imagePath = (name) => images(name, true)
+try {
+  window.airbrake = new Notifier({
+    projectId: window.env.AIRBRAKE_PROJECT_ID,
+    projectKey: window.env.AIRBRAKE_PROJECT_KEY,
+    host: window.env.PANEL_URL
+  });
+
+  const ignoredErrors = ["htmx:afterRequest", "htmx:sendAbort"];
+
+  console.originalError = console.error;
+  console.error = (...e) => {
+    const msg = e.join(" ");
+
+    if (!ignoredErrors.some(x => msg.includes(x))) {
+      window.airbrake.notify(e.join(" "));
+    }
+
+    return console.originalError(...e);
+  };
+} catch(e) {
+  console.error(e);
+}
 
 import 'core-js/stable'
 import 'regenerator-runtime/runtime'
 import 'controllers'
+import 'editor/editor'
+import 'fork-awesome/scss/fork-awesome.scss'
+import 'etc'
 
-import {EditorState} from "prosemirror-state"
-import {EditorView} from "prosemirror-view"
-import {schema, defaultMarkdownParser, defaultMarkdownSerializer} from "prosemirror-markdown"
-import {exampleSetup} from "prosemirror-example-setup"
+import Rails from '@rails/ujs'
+import Turbolinks from 'turbolinks'
+import * as ActiveStorage from '@rails/activestorage'
+import 'chartkick/chart.js'
 
-import "prosemirror-gapcursor/style/gapcursor.css"
-import "prosemirror-menu/style/menu.css"
-import "prosemirror-view/style/prosemirror.css"
-import "prosemirror-example-setup/style/style.css"
+Rails.start()
+Turbolinks.start()
+ActiveStorage.start()
 
-// Lista de equivalencias entre Date#getTimezoneOffset de JS y
-// MetadataEvent
-const timeZoneOffsets = {
-   '720': '-12:00',
-   '660': '-11:00',
-   '600': '-10:00',
-   '570': '-09:30',
-   '540': '-09:00',
-   '480': '-08:00',
-   '420': '-07:00',
-   '360': '-06:00',
-   '300': '-05:00',
-   '240': '-04:00',
-   '210': '-03:30',
-   '180': '-03:00',
-   '120': '-02:00',
-    '60': '-01:00',
-     '0': '00:00',
-   '-60': '+01:00',
-  '-120': '+02:00',
-  '-180': '+03:00',
-  '-210': '+03:30',
-  '-240': '+04:00',
-  '-270': '+04:30',
-  '-300': '+05:00',
-  '-330': '+05:30',
-  '-345': '+05:45',
-  '-360': '+06:00',
-  '-390': '+06:30',
-  '-420': '+07:00',
-  '-480': '+08:00',
-  '-525': '+08:45',
-  '-540': '+09:00',
-  '-570': '+09:30',
-  '-600': '+10:00',
-  '-630': '+10:30',
-  '-660': '+11:00',
-  '-720': '+12:00',
-  '-765': '+12:45',
-  '-780': '+13:00',
-  '-840': '+14:00'
-};
-
-// Obtiene el huso horario local 
-const timeZoneOffset = timeZoneOffsets[(new Date).getTimezoneOffset().toString()];
-
-document.addEventListener('turbolinks:load', () => {
-
-  // Aplicar el huso horario descubierto en los campos de evento solo
-  // cuando estamos creando un artículo.
-  document.querySelectorAll('.new .event .zone select').forEach(zone => zone.value = timeZoneOffset);
-
-  document.querySelectorAll('.markdown-content').forEach(mdc => {
-    let textArea = mdc.querySelector(".content"),
-        editor = mdc.querySelector(".markdown-editor");
-
-    let view = new EditorView(editor, {
-      state: EditorState.create({
-        doc: defaultMarkdownParser.parse(textArea.value),
-        plugins: exampleSetup({schema})
-      })
-    })
-
-    // Guardar los cambios al enviar el formulario y cada 10 segundos
-    textArea.form.addEventListener('submit', e => textArea.value = defaultMarkdownSerializer.serialize(view.state.doc));
-    setInterval(() => textArea.value = defaultMarkdownSerializer.serialize(view.state.doc), 10 * 1000);
-    // Ocultar el area
-    textArea.style.display = 'none'
-  })
-})
+window.htmx = require('htmx.org/dist/htmx.js')

app/jobs/activity_pub/fediblock_fetch_job.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+class ActivityPub
+  # Se encarga de mantener las listas de bloqueo actualizadas.  Luego de
+  # actualizar el listado de instancias, bloquea las instancias en cada
+  # sitio que tenga el fediblock habilitado.
+  class FediblockFetchJob < ApplicationJob
+    self.priority = 50
+
+    def perform
+      ActivityPub::Fediblock.find_each do |fediblock|
+        fediblock.process!
+
+        hostnames_added = fediblock.hostnames - fediblock.hostnames_was
+
+        # No hacer nada si no cambió con respecto a la versión anterior
+        next if hostnames_added.empty?
+
+        ActivityPub::FediblockUpdatedJob.perform_later(fediblock: fediblock, hostnames: hostnames_added)
+      rescue ActivityPub::Fediblock::FediblockDownloadError => e
+        ExceptionNotifier.notify_exception(e, data: { fediblock: fediblock.title })
+      end
+    end
+  end
+end

app/jobs/activity_pub/fediblock_updated_job.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+# Se encarga de mantener sincronizadas las listas de instancias
+# de los fediblocks con los sitios que las tengan activadas.
+#
+# También va a asociar las listas con todos los sitios que tengan la
+# Social Inbox habilitada.
+class ActivityPub
+  class FediblockUpdatedJob < ApplicationJob
+    self.priority = 50
+
+    # @param :fediblock [ActivityPub::Fediblock]
+    # @param :hostnames [Array<String>]
+    def perform(fediblock:, hostnames:)
+      instances = ActivityPub::Instance.where(hostname: hostnames)
+
+      # Todos los sitios con la Social Inbox habilitada
+      Site.where(id: DeploySocialDistributedPress.pluck(:site_id)).find_each do |site|
+        # Crea el estado si no existía
+        fediblock_state = site.fediblock_states.find_or_create_by(fediblock: fediblock)
+
+        # No hace nada con los deshabilitados
+        next unless fediblock_state.enabled?
+
+        ActivityPub::InstanceModerationJob.perform_later(site: site, hostnames: hostnames)
+      end
+    end
+  end
+end

app/jobs/activity_pub/fetch_job.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+# Obtiene o actualiza el contenido de un objeto, usando las credenciales
+# del sitio.
+#
+# XXX: Esto usa las credenciales del sitio para volver el objeto
+# disponible para todo el CMS.  Asumimos que el objeto devuelto es el
+# mismo para todo el mundo y las credenciales solo son para
+# autenticación.
+class ActivityPub
+  class FetchJob < ApplicationJob
+    self.priority = 50
+
+    attr_reader :object, :response
+
+    # Notificar errores de JSON con el contenido, tomar los errores de
+    # validación y conexión como errores temporales y notificar todo lo
+    # demás sin reintentar.
+    #
+    # @param error [Exception]
+    # @return [Bool]
+    discard_on(FastJsonparser::ParseError) do |error|
+      ExceptionNotifier.notify_exception(error, data: { site: site.name, object: object.uri, body: response.body })
+    end
+
+    retry_on ActiveRecord::RecordInvalid
+    retry_on SocketError, wait: ApplicationJob.random_wait
+    retry_on SystemCallError, wait: ApplicationJob.random_wait
+    retry_on Net::OpenTimeout, wait: ApplicationJob.random_wait
+    retry_on OpenSSL::OpenSSLError, wait: ApplicationJob.random_wait
+
+    def perform(site:, object_id:)
+      ActivityPub::Object.transaction do
+        @site = site
+        @object = ::ActivityPub::Object.find(object_id)
+
+        return if object.blank?
+        return if object.activity_pubs.where(aasm_state: 'removed').count.positive?
+
+        @response = site.social_inbox.dereferencer.get(uri: object.uri)
+
+        # @todo Fallar cuando la respuesta no funcione?
+        # @todo Eliminar en 410 Gone
+        return unless response.success?
+        # Ignorar si ya la caché fue revalidada y ya teníamos el
+        # contenido
+        return if response.hit? && object.content.present?
+
+        current_type = object.type
+        content = FastJsonparser.parse(response.body)
+
+        # Modificar atómicamente
+        ::ActivityPub::Object.lock.find(object_id).update!(content: content,
+                                                           type: ActivityPub::Object.type_from(content).name)
+
+        object = ::ActivityPub::Object.find(object_id)
+        # Actualiza la mención
+        object.actor&.save! if object.actor_type?
+
+        # Arreglar las relaciones con actividades también
+        ActivityPub.where(object_id: object.id).update_all(object_type: object.type, updated_at: Time.now)
+      end
+    end
+  end
+end

app/jobs/activity_pub/inbox_job.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+class ActivityPub
+  class InboxJob < ApplicationJob
+    self.priority = 10
+
+    # @param :site [Site]
+    # @param :activity [String]
+    # @param :action [Symbol]
+    def perform(site:, activity:, action:)
+      response = site.social_inbox.inbox.public_send(action, id: activity)
+
+      raise response.body unless response.success?
+    end
+  end
+end

app/jobs/activity_pub/instance_fetch_job.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+class ActivityPub
+  # Obtiene o actualiza los datos de una instancia.  Usamos un cliente
+  # de ActivityPub porque la instancia podría estar en federación
+  # limitada.
+  class InstanceFetchJob < ApplicationJob
+    self.priority = 100
+
+    def perform(site:, instance:)
+      %w[/api/v2/instance /api/v1/instance].each do |api|
+        uri = SocialInbox.generate_uri(instance.hostname) do |u|
+          u.path = api
+        end
+
+        response = site.social_inbox.dereferencer.get(uri: uri)
+
+        next unless response.success?
+        # @todo Validate schema
+        next unless response.parsed_response.is_a?(DistributedPress::V1::Social::ReferencedObject)
+
+        instance.update(content: response.parsed_response.object)
+
+        break
+      rescue BRS::BaseError,
+             Errno::ECONNREFUSED,
+             HTTParty::Error,
+             JSON::JSONError,
+             Net::OpenTimeout,
+             OpenSSL::OpenSSLError,
+             SocketError,
+             Errno::ENETUNREACH => e
+        ExceptionNotifier.notify_exception(e, data: { instance: uri })
+        break
+      end
+    end
+  end
+end

app/jobs/activity_pub/instance_moderation_job.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+class ActivityPub
+  # Bloquea varias instancias de una sola vez
+  class InstanceModerationJob < ApplicationJob
+    # @param :site [Site]
+    # @param :hostnames [Array<String>]
+    # @param :perform_remotely [Bool]
+    def perform(site:, hostnames:, perform_remotely: true)
+      # Crear las instancias que no existan todavía
+      hostnames.each do |hostname|
+        ActivityPub::Instance.lock.find_or_create_by(hostname: hostname)
+      end
+
+      instances = ActivityPub::Instance.where(hostname: hostnames)
+
+      Site.transaction do
+        # Crea todas las moderaciones de instancia con un estado por
+        # defecto si no existen
+        instances.find_each do |instance|
+          # Esto bloquea cada una individualmente en la Social Inbox,
+          # idealmente son pocas instancias las que aparecen.
+          site.instance_moderations.lock.find_or_create_by(instance: instance)
+        end
+
+        scope = site.instance_moderations.where(instance_id: instances.ids)
+
+        if perform_remotely
+          scope.block_all!
+        else
+          scope.block_all_without_callbacks!
+        end
+
+        ActivityPub::SyncListsJob.perform_later(site: site)
+      end
+    end
+  end
+end

app/jobs/activity_pub/process_job.rb

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+class ActivityPub
+  # Procesar las actividades a medida que llegan
+  class ProcessJob < ApplicationJob
+    attr_reader :body
+
+    retry_on ActiveRecord::RecordInvalid
+
+    # Procesa la actividad en segundo plano
+    #
+    # @param :body [String]
+    # @param :initial_state [Symbol,String]
+    def perform(site:, body:, initial_state: :paused)
+      @site = site
+      @body = body
+
+      ActiveRecord::Base.connection_pool.with_connection do
+        ::ActivityPub.transaction do
+          # Crea todos los registros necesarios y actualiza el estado
+          actor.present?
+          instance.present?
+          object.present?
+          activity_pub.present?
+          activity_pub.update(aasm_state: initial_state)
+
+          activity.update_activity_pub_state!
+        end
+      end
+    end
+
+    private
+
+    # Si el objeto ya viene incorporado en la actividad o lo tenemos
+    # que traer remotamente.
+    #
+    # @return [Bool]
+    def object_embedded?
+      @object_embedded ||= original_activity[:object].is_a?(Hash)
+    end
+
+    # Encuentra la URI del objeto o falla si no la encuentra.
+    #
+    # @return [String]
+    def object_uri
+      @object_uri ||= ::ActivityPub.uri_from_object(original_activity[:object])
+    ensure
+      raise ActiveRecord::RecordNotFound, 'object id missing' if @object_uri.blank?
+    end
+
+    # Atajo a la instancia
+    #
+    # @return [ActivityPub::Instance]
+    def instance
+      actor.instance
+    end
+
+    # Genera un objeto a partir de la actividad.  Si el objeto ya
+    # existe, actualiza su contenido.  Si el objeto no viene
+    # incorporado, obtenemos el contenido más tarde.
+    #
+    # @return [ActivityPub::Object]
+    def object
+      @object ||= ::ActivityPub::Object.lock.find_or_initialize_by(uri: object_uri).tap do |o|
+        o.lock! if o.persisted?
+        o.content = original_object if object_embedded?
+
+        o.save!
+
+        # XXX: el objeto necesita ser guardado antes de poder
+        # procesarlo.  No usamos GlobalID porque el tipo de objeto
+        # cambia y produce un error de deserialización.
+        ::ActivityPub::FetchJob.perform_later(site: site, object_id: o.id) unless object_embedded?
+      end
+    end
+
+    # Genera el seguimiento del estado del objeto con respecto al
+    # sitio.
+    #
+    # @return [ActivityPub]
+    def activity_pub
+      @activity_pub ||= site.activity_pubs.lock.find_or_create_by!(site: site, actor: actor, instance: instance,
+                                                                   object_id: object.id, object_type: object.type)
+    end
+
+    # Crea la actividad y la vincula con el estado
+    #
+    # @return [ActivityPub::Activity]
+    def activity
+      @activity ||=
+        ::ActivityPub::Activity
+        .type_from(original_activity)
+        .lock
+        .find_or_initialize_by(uri: original_activity[:id], activity_pub: activity_pub, actor: actor).tap do |a|
+          a.lock! if a.persisted?
+          a.content = original_activity.dup
+          a.content[:object] = object.uri
+          a.save!
+        end
+    end
+
+    # Actor, si no hay instancia, la crea en el momento, junto con
+    # su estado de moderación.
+    #
+    # @return [Actor]
+    def actor
+      @actor ||= ::ActivityPub::Actor.lock.find_or_initialize_by(uri: original_activity[:actor]).tap do |a|
+        a.lock! if a.persisted?
+
+        unless a.instance
+          a.instance = ::ActivityPub::Instance.lock.find_or_create_by(hostname: URI.parse(a.uri).hostname)
+
+          ::ActivityPub::InstanceFetchJob.perform_later(site: site, instance: a.instance)
+        end
+
+        site.instance_moderations.lock.find_or_create_by(instance: a.instance)
+        a.save!
+
+        site.actor_moderations.lock.find_or_create_by(actor: a)
+
+        ::ActivityPub::FetchJob.perform_later(site: site, object_id: a.object.id)
+      end
+    end
+
+    # @return [Hash,String]
+    def original_object
+      @original_object ||= original_activity[:object].dup.tap do |o|
+        o[:@context] = original_activity[:@context].dup
+      end
+    end
+
+    # Descubre la actividad recibida, generando un error si la
+    # actividad no está dirigida a nosotres.
+    #
+    # @todo Validar formato con Dry::Schema
+    # @return [Hash]
+    def original_activity
+      @original_activity ||= FastJsonparser.parse(body).tap do |activity|
+        raise '@context missing' unless activity[:@context].present?
+        raise 'id missing' unless activity[:id].present?
+        raise 'object missing' unless activity[:object].present?
+      end
+    end
+  end
+end

app/jobs/activity_pub/remote_flag_job.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+# Envía un reporte directamente a la instancia remota
+#
+# @todo El panel debería ser su propia instancia y firmar sus propios
+# mensajes.
+# @todo Como la Social Inbox no soporta enviar actividades
+# a destinataries que no sean seguidores, enviamos el reporte
+# directamente a la instancia.
+# @see {https://github.com/hyphacoop/social.distributed.press/issues/14}
+class ActivityPub
+  class RemoteFlagJob < ApplicationJob
+    self.priority = 30
+
+    def perform(remote_flag:)
+      return unless remote_flag.may_queue?
+
+      inbox = remote_flag.actor&.content&.[]('inbox')
+
+      raise 'Inbox is missing for actor' if inbox.blank?
+
+      remote_flag.queue!
+
+      uri = URI.parse(inbox)
+      client = remote_flag.main_site.social_inbox.client_for(uri.origin)
+      response = client.post(endpoint: uri.path, body: remote_flag.content)
+
+      raise 'No se pudo enviar el reporte' unless response.success?
+
+      remote_flag.report!
+    rescue Exception => e
+      ExceptionNotifier.notify_exception(e, data: { remote_flag: remote_flag.id, response: response.parsed_response })
+      remote_flag.resend!
+      raise
+    end
+  end
+end

app/jobs/activity_pub/sync_lists_job.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+class ActivityPub
+  # Sincroniza las listas de bloqueo y permitidas con el estado actual
+  # de la base de datos.
+  class SyncListsJob < ApplicationJob
+    # Siempre correr al final
+    self.priority = 100
+
+    attr_reader :logs
+
+    # Ejecuta todas las requests y consolida los posibles errores.
+    #
+    # @param site [Site]
+    def run(site:)
+      @logs = {}
+
+      instance_scope = site.instance_moderations.joins(:instance)
+      actor_scope = site.actor_moderations.joins(:actor)
+
+      blocklist = wildcardize(instance_scope.blocked.pluck(:hostname)) + actor_scope.blocked.distinct.pluck(:mention).compact + actor_scope.reported.distinct.pluck(:mention).compact
+      allowlist = wildcardize(instance_scope.allowed.pluck(:hostname)) + actor_scope.allowed.distinct.pluck(:mention).compact
+      pauselist = wildcardize(instance_scope.paused.pluck(:hostname)) + actor_scope.paused.distinct.pluck(:mention).compact
+
+      if blocklist.present?
+        Rails.logger.info "Bloqueando: #{blocklist.join(', ')}"
+        process(:blocked) { site.social_inbox.allowlist.delete(list: blocklist) }
+        process(:blocked) { site.social_inbox.blocklist.post(list: blocklist) }
+      end
+
+      if allowlist.present?
+        Rails.logger.info "Permitiendo: #{allowlist.join(', ')}"
+        process(:allowed) { site.social_inbox.blocklist.delete(list: allowlist) }
+        process(:allowed) { site.social_inbox.allowlist.post(list: allowlist) }
+      end
+
+      if pauselist.present?
+        Rails.logger.info "Pausando: #{pauselist.join(', ')}"
+        process(:paused) { site.social_inbox.blocklist.delete(list: pauselist) }
+        process(:paused) { site.social_inbox.allowlist.delete(list: pauselist) }
+      end
+
+      # Si alguna falló, reintentar
+      raise if logs.present?
+    rescue Exception => e
+      ExceptionNotifier.notify_exception(e,
+                                         data: { site: site.name, logs: logs, blocklist: blocklist,
+                                                 allowlist: allowlist, pauselist: pauselist })
+
+      raise
+    end
+
+    private
+
+    def process(stage)
+      response = yield
+
+      return if response.success?
+
+      logs[stage] ||= []
+      logs[stage] << { body: response.body, code: response.code }
+    end
+
+    # @params hostnames [Array<String>]
+    # @return [Array<String>]
+    def wildcardize(hostnames)
+      hostnames.map do |hostname|
+        "@*@#{hostname}"
+      end
+    end
+  end
+end

app/jobs/application_job.rb

@@ -2,11 +2,23 @@
 
 # Base para trabajos
 class ApplicationJob < ActiveJob::Base
-  include SuckerPunch::Job
+  include Que::ActiveJob::JobExtensions
 
-  private
+  # Esperar una cantidad random de segundos primos, para que no se
+  # superpongan tareas
+  #
+  # @return [Array<Integer>]
+  RANDOM_WAIT = [3, 5, 7, 11, 13].freeze
 
-  def site
-    @site ||= Site.find @params[:site_id]
+  # @return [ActiveSupport::Duration]
+  def self.random_wait
+    RANDOM_WAIT.sample.seconds
+  end
+
+  attr_reader :site
+
+  # Si falla por cualquier cosa informar y descartar
+  discard_on(Exception) do |job, error|
+    ExceptionNotifier.notify_exception(error, data: { job: job })
   end
 end

app/jobs/backtrace_job.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+# Procesa los errores de JavaScript
+class BacktraceJob < ApplicationJob
+  class BacktraceException < RuntimeError; end
+
+  EMPTY_SOURCEMAP = { 'mappings' => '' }.freeze
+
+  attr_reader :params
+
+  def perform(site:, params:)
+    @site = site
+    @params = params
+
+    unless sources.empty?
+      params['errors'].each do |error|
+        error['backtrace'].each do |backtrace|
+          offset = SourceMap::Offset.new(backtrace['line'], backtrace['column'])
+          mapping = sourcemap.bsearch(offset)
+
+          next unless mapping
+
+          data = data(backtrace['file'])
+
+          backtrace['file'] = mapping.source
+          backtrace['line'] = mapping.original.line
+          backtrace['column'] = mapping.original.column
+
+          # Encuentra el código fuente del error
+          source = data.dig('sourcesContent', data['sources']&.index(backtrace['file']))&.split("\n")
+          # XXX: Elimina la sangría aunque cambie las columnas porque
+          # eso lo vamos a ver en el archivo fuente directo.
+          backtrace['function'] = source[backtrace['line'] - 1].strip if source.present?
+        end
+      end
+    end
+
+    begin
+      raise BacktraceException, "#{origin}: #{message}"
+    rescue BacktraceException => e
+      ExceptionNotifier.notify_exception(e, data: { site: site.name, params: params, javascript_backtrace: true })
+    end
+  end
+
+  private
+
+  # Obtiene todos los archivos del backtrace solo si los puede descargar
+  # desde fuentes seguras.
+  #
+  # XXX: Idealmente no trabajamos con recursos externos, pero en este
+  # momento no podemos saber todas las URLs de un sitio y quizás nunca
+  # lo sabremos :B
+  def sources
+    @sources ||= params['errors'].map do |x|
+                   x['backtrace']
+                 end.flatten.map do |x|
+                   x['file'].split('@').last
+                 end.uniq.grep(%r{\Ahttps://})
+  end
+
+  # Descarga y devuelve los datos de un archivo
+  #
+  # @param [String] La URL del map
+  # @return [Hash]
+  def data(map)
+    return EMPTY_SOURCEMAP unless map.start_with? 'https://'
+
+    map += '.map' unless map.end_with? '.map'
+
+    @data      ||= {}
+    # TODO: Soportar ETags para la descarga, probablemente pasar a
+    # Faraday con caché para esto.
+    @data[map] ||= FastJsonparser.parse(Rails.cache.fetch(map, expires_in: 12.hours) do
+                                          Down.open(map).read
+                                        end, symbolize_keys: false)
+  rescue Down::Error, FastJsonparser::Error
+    EMPTY_SOURCEMAP
+  end
+
+  # Asume que todos los sourcemaps comparten la misma URL, lo
+  # correcto sería buscarlo en sourceMappingURL al final de cada
+  # archivo.
+  #
+  # Descarga los archivos y obtiene el backtrace original.
+  #
+  # @return [SourceMap::Map]
+  def sourcemap
+    @sourcemap ||= sources.map do |map|
+      SourceMap::Map.from_hash data(map)
+    end.reduce(&:+)
+  end
+
+  # @return [String]
+  def origin
+    URI.parse(params.dig('context', 'url')).host
+  rescue URI::Error
+    params.dig('context', 'url')
+  end
+
+  # @return [String,Nil]
+  def message
+    @message ||= params['errors']&.first&.dig('message')
+  end
+end

app/jobs/cleanup_job.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+# Realiza tareas de limpieza en segundo plano
+class CleanupJob < ApplicationJob
+  def perform(before = nil)
+    CleanupService.new(before: before).cleanup_everything!
+  end
+end

app/jobs/concerns/recursive_rollup.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+# Implementa rollups recursivos
+module RecursiveRollup
+  extend ActiveSupport::Concern
+
+  included do
+    private
+
+    # Genera un rollup recursivo en base al período anterior y aplica una
+    # operación.
+    #
+    # @param :name [String]
+    # @param :interval_previous [String]
+    # @param :interval [String]
+    # @param :operation [Symbol]
+    # @param :dimensions [Hash]
+    # @param :beginning [Time]
+    # @return [Rollup]
+    def recursive_rollup(name:, interval_previous:, interval:, dimensions:, beginning:, operation: :sum)
+      Rollup.where(name: name, interval: interval_previous, dimensions: dimensions)
+            .where('time >= ?', beginning.try(:"beginning_of_#{interval}"))
+            .group(*dimensions_to_jsonb_query(dimensions))
+            .rollup(name, interval: interval, update: true) do |rollup|
+              rollup.try(operation, :value)
+            end
+    end
+
+    # Reducir las estadísticas calculadas aplicando un rollup sobre el
+    # intervalo más amplio.
+    #
+    # @param :name [String]
+    # @param :operation [Symbol]
+    # @param :dimensions [Hash]
+    # @return [nil]
+    def reduce_rollup(name:, dimensions:, operation: :sum)
+      Stat::INTERVALS.reduce do |previous, current|
+        recursive_rollup(name: name,
+                         interval_previous: previous,
+                         interval: current,
+                         dimensions: dimensions,
+                         beginning: beginning_of_interval,
+                         operation: operation)
+
+        # Devolver el intervalo actual
+        current
+      end
+
+      nil
+    end
+
+    # @param :dimensions [Hash]
+    # @return [Array]
+    def dimensions_to_jsonb_query(dimensions)
+      dimensions.keys.map do |key|
+        "dimensions->'#{key}'"
+      end
+    end
+  end
+end

app/jobs/contact_job.rb

@@ -5,13 +5,11 @@ class ContactJob < ApplicationJob
   # @param [Integer]
   # @param [String]
   # @param [Hash]
-  def perform(site_id, form_name, form)
-    # Retrocompabilidad al actualizar a 2.7.1
-    # @see ApplicationJob#site
-    @params = { site_id: site_id }
+  def perform(site, form_name, form, origin = nil)
+    @site = site
 
     # Sanitizar los valores
-    form.keys.each do |key|
+    form.each_key do |key|
       form[key] = ActionController::Base.helpers.sanitize form[key]
     end
 
@@ -23,8 +21,9 @@ class ContactJob < ApplicationJob
     usuaries.each_slice(10) do |u|
       ContactMailer.with(form_name: form_name,
                          form: form,
-                         site_id: site_id,
-                         usuaries_emails: u)
+                         site: site,
+                         usuaries_emails: u,
+                         origin: origin)
                    .notify_usuaries.deliver_now
     end
   end