federails 0.6.2 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 28392d4e043a74e77e376374a27a4ee2c86c604b90d0fa0ac7e9ecc337a21630
-  data.tar.gz: cebe905ce0a273bff88ca969a8b0bf72d2f9bc287210dcaf7fd48042a182edce
+  metadata.gz: 36117bc1ea548be65aebe4ee505850ecac3233851f07aaae18136188ec1c1077
+  data.tar.gz: '0958b68fce09e2775504b28f5227e098470c0cb3c89eb4ca3dec7f5ece871d78'
 SHA512:
-  metadata.gz: 660950645cf4a9af0d3d8dd34337a3857d038f487cc22a3199d78d9cdcdfc17cad165955aba8163c1e2c084be39fdbd639c571b7a9bd88658fed96f2d73b1615
-  data.tar.gz: cfcf8fc68460ef4eb7e66e9d4a459cf29863f2330f903d5967ef5d4bb43f3817963e355eb3690d84798674664dce0267ccb0ab05772274e2cb06a97aa152bf2b
+  metadata.gz: 2f6e4dc1e3554b81a02710b9d893c88ffa77ff7c33e623574378cd7b87a13165297dcd4b22a4ce38e90073a545708d7d82e17e9867b1f345a1ebcad2c1cdf237
+  data.tar.gz: a8fb6f9811a9369ee7cf706c64517f47c8a66b335de715b8325e508ca6790dc4e1f7db6ae67b62651920cf3fd467d1c2e23263fb5b4f38f2d40a2c1d5a9cdfc2

data/README.md

@@ -40,6 +40,13 @@ It _may_ work on other versions, but we won't provide support.
 - [Common questions](docs/faq.md)
 - [Contributing](CONTRIBUTING.md)
 
+## Extensions
+
+Extensions extends the features of Federails.
+
+- [Federails Moderation](https://github.com/manyfold3d/federails-moderation/)
+  > A gem that provides moderation capabilities for Federails
+
 ## License
 
 The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
@@ -53,6 +60,7 @@ See [CONTRIBUTING](CONTRIBUTING.md) to have an overview of the process and the t
 - [echarp](https://gitlab.com/echarp)
 - [James Smith](https://gitlab.com/floppy.uk)
 - [Manuel Tancoigne](https://gitlab.com/mtancoigne)
+- [pessi-v](https://github.com/pessi-v)
 
 ### Indirect contributions
 

data/app/controllers/concerns/federails/server/render_collections.rb

@@ -0,0 +1,19 @@
+module Federails
+  module Server
+    module RenderCollections
+      extend ActiveSupport::Concern
+
+      def render_collection(actor:, collection:, url_helper:, &items_block)
+        if params[:page].present?
+          render_collection_page(actor: actor, collection: collection, url_helper: url_helper, items_block: items_block)
+        else
+          render 'federails/server/shared/ordered_collection', locals: { collection: collection, url_helper: url_helper, actor: actor }
+        end
+      end
+
+      def render_collection_page(collection:, actor:, url_helper:, items_block:)
+        render 'federails/server/shared/ordered_collection_page', locals: { collection: collection, url_helper: url_helper, actor: actor, items_block: items_block }
+      end
+    end
+  end
+end

data/app/controllers/federails/client/actors_controller.rb

@@ -35,7 +35,7 @@ module Federails
       end
 
       def account_param
-        params.require('account')
+        params.require('account').strip
       end
 
       def render_show

data/app/controllers/federails/client/followings_controller.rb

@@ -8,7 +8,7 @@ module Federails
       # GET /app/followings/new?uri={uri}
       def new
         # Find actor (and fetch if necessary)
-        actor = Actor.find_or_create_by_federation_url(params[:uri])
+        actor = Actor.find_or_create_by_federation_url(params.require(:uri))
         # Redirect to local profile page which will have a follow button on it
         redirect_to federails.client_actor_url(actor)
       end
@@ -23,7 +23,7 @@ module Federails
             format.json { render :show, status: :ok, location: @following }
           else
             format.html { redirect_to url, alert: I18n.t('controller.followings.accept.error') }
-            format.json { render json: @following.errors, status: :unprocessable_entity }
+            format.json { render json: @following.errors, status: Federails::Utils::ResponseCodes::UNPROCESSABLE_CONTENT }
           end
         end
       end
@@ -49,7 +49,7 @@ module Federails
           # Renders a 422 instead of a 404
           respond_to do |format|
             format.html { redirect_to federails.client_actors_url, alert: I18n.t('controller.followings.follow.error') }
-            format.json { render json: { target_actor: ['does not exist'] }, status: :unprocessable_entity }
+            format.json { render json: { target_actor: ['does not exist'] }, status: Federails::Utils::ResponseCodes::UNPROCESSABLE_CONTENT }
           end
 
           return
@@ -94,7 +94,7 @@ module Federails
             format.json { render :show, status: :created, location: @following }
           else
             format.html { redirect_to url, alert: I18n.t('controller.followings.save_and_render.error') }
-            format.json { render json: @following.errors, status: :unprocessable_entity }
+            format.json { render json: @following.errors, status: Federails::Utils::ResponseCodes::UNPROCESSABLE_CONTENT }
           end
         end
       end

data/app/controllers/federails/server/activities_controller.rb

@@ -3,6 +3,8 @@ require 'fediverse/inbox'
 module Federails
   module Server
     class ActivitiesController < Federails::ServerController
+      include Federails::Server::RenderCollections
+
       before_action :set_activity, only: [:show]
 
       # GET /federation/activities
@@ -10,10 +12,16 @@ module Federails
       def outbox
         authorize Federails::Activity, policy_class: Federails::Server::ActivityPolicy
 
-        @actor            = Actor.find_param(params[:actor_id])
-        @activities       = policy_scope(Federails::Activity, policy_scope_class: Federails::Server::ActivityPolicy::Scope).where(actor: @actor).order(created_at: :desc)
-        @total_activities = @activities.count
-        @activities       = @activities.page(params[:page])
+        actor            = Actor.find_param(params[:actor_id])
+        activities       = policy_scope(Federails::Activity, policy_scope_class: Federails::Server::ActivityPolicy::Scope).where(actor: actor).order(created_at: :desc)
+
+        render_collection(
+          collection: activities.page(params[:page]),
+          actor:      actor,
+          url_helper: :server_actor_outbox_url
+        ) do |builder, items|
+          builder.array! items, partial: 'federails/server/activities/activity', as: :activity, context: false
+        end
       end
 
       # GET /federation/actors/1/activities/1.json
@@ -24,12 +32,12 @@ module Federails
         skip_authorization
 
         payload = payload_from_params
-        return head :unprocessable_entity unless payload
+        return head Federails::Utils::ResponseCodes::UNPROCESSABLE_CONTENT unless payload
 
         if Fediverse::Inbox.dispatch_request(payload)
           head :created
         else
-          head :unprocessable_entity
+          head Federails::Utils::ResponseCodes::UNPROCESSABLE_CONTENT
         end
       end
 

data/app/controllers/federails/server/actors_controller.rb

@@ -1,6 +1,8 @@
 module Federails
   module Server
     class ActorsController < Federails::ServerController
+      include Federails::Server::RenderCollections
+
       before_action :set_actor, only: [:show, :followers, :following]
 
       # GET /federation/actors/1
@@ -14,14 +16,26 @@ module Federails
       # GET /federation/actors/:id/followers.json
       def followers
         @actors = @actor.followers.order(created_at: :desc)
-        followings_queries
+        render_collection(
+          collection: @actors.page(params[:page]),
+          actor:      @actor,
+          url_helper: :followers_server_actor_url
+        ) do |builder, items|
+          builder.array! items.map(&:federated_url)
+        end
       end
 
       # GET /federation/actors/:id/followers
       # GET /federation/actors/:id/followers.json
       def following
         @actors = @actor.follows.order(created_at: :desc)
-        followings_queries
+        render_collection(
+          collection: @actors.page(params[:page]),
+          actor:      @actor,
+          url_helper: :following_server_actor_url
+        ) do |builder, items|
+          builder.array! items.map(&:federated_url)
+        end
       end
 
       private
@@ -31,11 +45,6 @@ module Federails
         @actor = Actor.find_param(params[:id])
         authorize @actor, policy_class: Federails::Server::ActorPolicy
       end
-
-      def followings_queries
-        @total_actors = @actors.count
-        @actors       = @actors.page(params[:page])
-      end
     end
   end
 end

data/app/controllers/federails/server/nodeinfo_controller.rb

@@ -18,8 +18,8 @@ module Federails
           @has_user_counts = true
           model = config[:class]
           @total += model.send(method, nil)
-          @active_month += model.send(method, ((30.days.ago)...Time.current))
-          @active_halfyear += model.send(method, ((180.days.ago)...Time.current))
+          @active_month += model.send(method, (30.days.ago)...Time.current)
+          @active_halfyear += model.send(method, (180.days.ago)...Time.current)
         end
         render formats: [:nodeinfo]
       end

data/app/helpers/federails/server_helper.rb

@@ -1,3 +1,5 @@
+require 'federails/utils/context'
+
 module Federails
   module ServerHelper
     def remote_follow_url
@@ -8,5 +10,9 @@ module Federails
         Rails.application.routes.url_helpers.send(method_name)
       end
     end
+
+    def set_json_ld_context(json, additional: nil)
+      json.set! '@context', Federails::Utils::Context.generate(additional: additional)
+    end
   end
 end

data/app/jobs/federails/application_job.rb

@@ -1,5 +1,7 @@
 module Federails
   class ApplicationJob < ActiveJob::Base
+    queue_as { Configuration.job_queue.to_sym }
+
     discard_on ActiveJob::DeserializationError
     after_discard do |_job, exception|
       Rails.logger.info exception.to_s

data/app/jobs/federails/fetch_nodeinfo_job.rb

@@ -0,0 +1,10 @@
+require 'fediverse/notifier'
+
+module Federails
+  class FetchNodeinfoJob < ApplicationJob
+    # @param domain [String] Domain to create/update
+    def perform(domain)
+      Federails::Host.create_or_update domain, min_update_interval: Federails::Configuration.remote_entities_cache_duration
+    end
+  end
+end

data/app/jobs/federails/notify_inbox_job.rb

@@ -2,8 +2,6 @@ require 'fediverse/notifier'
 
 module Federails
   class NotifyInboxJob < ApplicationJob
-    queue_as :default
-
     def perform(activity)
       activity.reload
       Fediverse::Notifier.post_to_inboxes(activity)

data/app/models/concerns/federails/actor_entity.rb

@@ -156,7 +156,11 @@ module Federails
     end
 
     def tombstone_federails_actor!
-      federails_actor.tombstone! if federails_actor.present?
+      federails_actor.presence&.tombstone!
+    end
+
+    def untombstone_federails_actor!
+      federails_actor.presence&.untombstone!
     end
   end
 end

data/app/models/concerns/federails/data_entity.rb

@@ -12,9 +12,18 @@ module Federails
   #
   # ## Pre-requisites
   #
-  # Model must have a `federated_url` attribute:
+  # Model should have the following methods:
+  #  - `to_activitypub_object`, returning a valid ActivityPub object
+  #  - `self.from_activitypub_object`, returning a hash of valid attributes from a hash of incoming data
+  #
+  #  Table needs at least:
+  #  - `t.string :federated_url, null: true, default: nil`
+  #  - `t.references :federails_actor, foreign_key: true, null: true, default: nil
+  #
+  # Model must have the following attributes:
   # ```rb
   # add_column :posts, :federated_url, :string, null: true, default: nil
+  # add_reference :posts, :federails_actor, foreign_key: true, null: true, default: nil
   # ```
   #
   # ## Usage
@@ -29,6 +38,61 @@ module Federails
   #   # This will be called when a Delete activity comes for the entry. As we don't know how you want to handle it,
   #   # you'll have to implement the behavior yourself.
   #   on_federails_delete_requested :do_something
+  #
+  #   # This will be called when a Undo activity comes for the entry. The easiest way to handle this case is to re-fetch
+  #   # the entity
+  #   on_federails_undelete_requested :do_something_else
+  #
+  #   def to_activitypub_object
+  #     Federails::DataTransformer::Note.to_federation self,
+  #                                                    content: content,
+  #                                                    name:    title
+  #   end
+  #
+  #   # Creates a hash of attributes from incoming Note
+  #   def self.from_activitypub_object(hash)
+  #     {
+  #       title:   hash['name'] || 'A post',
+  #       content: hash['content'],
+  #     }
+  #   end
+  # end
+  # ```
+  #
+  # **If your model has a mechanism for soft deletion:**
+  # - you can specify some methods names to handle it in Federails responses:
+  # - you will need to send the delete activity yourself
+  #
+  # ```rb
+  # acts_as_federails_data handles: 'Note',
+  #                        ...,
+  #                        soft_deleted_method: :deleted?
+  #                        soft_delete_date_method: :deleted_at
+  #
+  # on_federails_delete_requested :soft_delete!
+  # on_federails_undelete_requested :restore_remote_entity!
+  #
+  # # Method you use to soft-delete entities
+  # def soft_delete!
+  #   update deleted_at: time.current
+  #
+  #   send_federails_activity 'Delete' unless local_federails_entity?
+  # end
+  #
+  # # Method you use to restore soft-deleted entities
+  # def restore!
+  #   update deleted_at: nil
+  #
+  #   if local_federails_entity?
+  #     delete_activity =  Activity.find_by action: 'Delete', entity: self
+  #     send_federails_activity 'Undo', entity: delete_activity, actor: federails_actor if delete_activity.present?
+  #   end
+  # end
+  #
+  # def restore_remote_entity!
+  #   self.deleted_at: nil
+  #   federails_sync!
+  #   save!
   # end
   # ```
   module DataEntity
@@ -41,9 +105,6 @@ module Federails
     module ClassMethods
       # Configures the mapping between entity and Fediverse
       #
-      # Model should have the following methods:
-      # - `to_activitypub_object`, returning a valid ActivityPub object
-      #
       # @param actor_entity_method [Symbol] Method returning an object responding to 'federails_actor', for local content
       # @param url_param [Symbol] Column name of the object ID that should be used in URLs. Defaults to +:id+
       # @param route_path_segment [Symbol] Segment used in Federails routes to display the ActivityPub representation.
@@ -56,9 +117,9 @@ module Federails
       # @param should_federate_method [Symbol] method to determine if an object should be federated. If the method returns false,
       #   no create/update activities will happen, and object will not be accessible at federated_url. Defaults to a method
       #   that always returns true.
-      # @param soft_deleted_method [Symbol, nil] Method to soft-delete the object when receiving a Delete request. This
-      #   is not required by the spec but greatly encouraged as the app will return a 410 response with a Tombstone object
-      #   instead of an 404 error.
+      # @param soft_deleted_method [Symbol, nil] If the model uses a soft-delete mechanism, this is the method to check
+      #   if entity is soft-deleted. This is not required by the spec but greatly encouraged as the app will return a 410
+      #   response with a Tombstone object instead of an 404 error.
       # @param soft_delete_date_method [Symbol, nil] Method to get the date of the soft-deletion
       #
       # @example
@@ -142,7 +203,7 @@ module Federails
 
       before_validation :set_federails_actor
       after_create -> { create_federails_activity 'Create' }
-      after_update -> { create_federails_activity 'Update' }, :federails_tombstoned?
+      after_update -> { create_federails_activity 'Update' }, unless: :federails_tombstoned?
       after_destroy -> { create_federails_activity 'Delete' }
     end
 
@@ -177,6 +238,17 @@ module Federails
       Federails.data_entity_configuration(self)
     end
 
+    def federails_sync!
+      if local_federails_entity?
+        Rails.logger.info { "Ignored attempt to sync a local #{self.class.name}" }
+        return false
+      end
+
+      object = Fediverse::Request.dereference(federated_url)
+
+      update! self.class.from_activitypub_object(object)
+    end
+
     private
 
     def set_federails_actor

data/app/models/concerns/federails/handles_delete_requests.rb

@@ -22,10 +22,15 @@ module Federails
       def on_federails_delete_requested(*args)
         set_callback :on_federails_delete_requested, *args
       end
+
+      def on_federails_undelete_requested(*args)
+        set_callback :on_federails_undelete_requested, *args
+      end
     end
 
     included do
       define_callbacks :on_federails_delete_requested
+      define_callbacks :on_federails_undelete_requested
     end
   end
 end

data/app/models/federails/activity.rb

@@ -24,31 +24,24 @@ module Federails
 
     after_create_commit :post_to_inboxes
 
-    # Determines the list of actors targeted by the activity
-    #
-    # @return [Array<Federails::Actor>]
-    def recipients
-      return [] unless actor.local?
-
-      case action
-      when 'Follow'
-        [entity]
-      when 'Undo'
-        [entity.entity]
-      when 'Accept'
-        [entity.actor]
-      else
-        default_recipient_list
-      end
-    end
+    before_validation :set_default_addressing, on: :create
+
+    serialize :cc, coder: YAML
+    serialize :to, coder: YAML
 
     private
 
-    def default_recipient_list
-      list = actor.followers
-      # If local actor is the subject, notify that actor's followers as well
-      list += entity.followers if entity.is_a?(Federails::Actor) && entity.local?
-      list.uniq
+    # Sets up default public-and-followers addressing unless to and cc are already set
+    #
+    # This retains compatibility with previous behaviour
+    def set_default_addressing
+      return if to.present? || cc.present?
+
+      self.to = [Fediverse::Collection::PUBLIC]
+      self.cc = [
+        actor.followers_url,
+        (entity.try(:followers_url) if entity.try(:local?)),
+      ].compact.uniq
     end
 
     def post_to_inboxes

data/app/models/federails/actor.rb

@@ -33,15 +33,24 @@ module Federails
     has_many :activities_as_entity, class_name: 'Federails::Activity', as: :entity, dependent: :destroy
     has_many :following_followers, class_name: 'Federails::Following', foreign_key: :target_actor_id, dependent: :destroy, inverse_of: :target_actor
     has_many :following_follows, class_name: 'Federails::Following', dependent: :destroy, inverse_of: :actor
+    # Actors following actor
     has_many :followers, source: :actor, through: :following_followers
+    # Actors followed by actor
     has_many :follows, source: :target_actor, through: :following_follows
+    belongs_to :host, class_name: 'Federails::Host', foreign_key: :server, primary_key: :domain, inverse_of: :actors, optional: true
+
+    # Explicitly explain serialization for MariaDB
+    attribute :extensions, :json
 
     scope :local, -> { where(local: true) }
     scope :distant, -> { where(local: false) }
     scope :tombstoned, -> { where.not(tombstoned_at: nil) }
     scope :not_tombstoned, -> { where(tombstoned_at: nil) }
 
+    after_create -> { FetchNodeinfoJob.perform_later(server) }, unless: :local?
+
     on_federails_delete_requested -> { tombstone! }
+    on_federails_undelete_requested -> { untombstone! }
 
     def distant?
       !local?
@@ -96,8 +105,8 @@ module Federails
       Rails.application.routes.url_helpers.send method, [entity]
     end
 
-    def at_address
-      "@#{username}@#{server}"
+    def at_address(prefix: '@')
+      "#{prefix}#{username}@#{server}"
     end
 
     def short_at_address
@@ -108,9 +117,22 @@ module Federails
       "acct:#{username}@#{server}"
     end
 
+    # Checks if a given actor follows the current actor
+    #
+    # @return [Federails::Following, false]
     def follows?(actor)
       list = following_follows.where target_actor: actor
-      return list.first if list.count == 1
+      return list.first if list.one?
+
+      false
+    end
+
+    # Checks if current actor is followed by the given actor
+    #
+    # @return [Federails::Following, false]
+    def followed_by?(actor)
+      list = following_followers.where actor: actor
+      return list.first if list.one?
 
       false
     end
@@ -121,6 +143,21 @@ module Federails
       Federails.actor_entity entity_type
     end
 
+    # Synchronizes actor with distant data
+    #
+    # @raise [ActiveRecord::RecordNotFound] when distant data was not found
+    def sync!
+      if local?
+        Rails.logger.info 'Ignored attempt to sync a local actor'
+        return false
+      end
+
+      response = Fediverse::Webfinger.fetch_actor_url(federated_url)
+      new_attributes = response.attributes.except 'id', 'uuid', 'created_at', 'updated_at', 'local', 'entity_id', 'entity_type'
+
+      update! new_attributes
+    end
+
     def tombstoned?
       tombstoned_at.present?
     end
@@ -129,6 +166,10 @@ module Federails
       Federails::Utils::Actor.tombstone! self
     end
 
+    def untombstone!
+      Federails::Utils::Actor.untombstone! self
+    end
+
     class << self
       # Searches for an actor from account URI
       #

data/app/models/federails/following.rb

@@ -28,7 +28,7 @@ module Federails
 
     def accept!
       update! status: :accepted
-      Activity.create! actor: target_actor, action: 'Accept', entity: self
+      Activity.create! actor: target_actor, action: 'Accept', entity: self, to: [actor.federated_url]
     end
 
     def follow_activity
@@ -62,11 +62,11 @@ module Federails
     end
 
     def create_activity
-      Activity.create! actor: actor, action: 'Follow', entity: target_actor
+      Activity.create! actor: actor, action: 'Follow', entity: target_actor, to: [target_actor.federated_url]
     end
 
     def destroy_activity
-      Activity.create! actor: actor, action: 'Undo', entity: follow_activity
+      Activity.create! actor: actor, action: 'Undo', entity: follow_activity, to: [target_actor.federated_url]
     end
   end
 end

data/app/models/federails/host.rb

@@ -0,0 +1,48 @@
+require 'fediverse/node_info'
+
+module Federails
+  class Host < ApplicationRecord
+    attribute :protocols, :json
+    attribute :services, :json
+
+    validates :domain, presence: true, allow_blank: false, uniqueness: true
+
+    # No "dependent" option here as this is not a hard reference, and we want to keep the actors if the host gets deleted
+    has_many :actors, class_name: 'Federails::Actor', primary_key: :domain, foreign_key: :server, inverse_of: :host # rubocop:disable Rails/HasManyOrHasOneDependent
+
+    scope :same_app, -> { where software_name: Configuration.app_name }
+    scope :same_app_and_version, -> { same_app.where app_version: Configuration.app_version }
+
+    def same_app?
+      software_name == Configuration.app_name
+    end
+
+    def same_app_and_version?
+      software_name == Configuration.app_name && app_version == Configuration.app_version
+    end
+
+    # Update from remote data
+    def sync!
+      update! Fediverse::NodeInfo.fetch(domain)
+    end
+
+    class << self
+      # Creates or update a Host
+      #
+      # @param domain              [String] Domain to check
+      # @param min_update_interval [Integer, ActiveSupport::Duration] Minimum amount of seconds since the last update to fetch fresh data
+      def create_or_update(domain, min_update_interval: 0)
+        entry = find_or_initialize_by domain: domain
+        return if min_update_interval && entry.persisted? && (entry.updated_at + min_update_interval) > Time.current
+
+        entry.sync!
+
+        entry
+      rescue Fediverse::NodeInfo::NoActivityPubError
+        Rails.logger.info { "#{domain} does not provide ActivityPub service" }
+      rescue Federails::Utils::JsonRequest::UnhandledResponseStatus, Faraday::SSLError => e
+        Rails.logger.info { "Error connecting to #{domain}: '#{e.message}'" }
+      end
+    end
+  end
+end

data/app/views/federails/client/common/_client_links.html.erb

@@ -17,7 +17,9 @@ Federation:
 </ul>
 
 <%# Debug information%>
-<% if !Federails::actor_entity?(user) %>
+<% if !user %>
+  Register or login to view your actor's information
+<% elsif !Federails::actor_entity?(user) %>
   <p><%= user.class.name %> is not configured to have an associated actor; you won't be allowed to follow or be followed</p>
 <% elsif !user.federails_actor.present? %>
   <p>Your account does not have an associated actor; you won't be allowed to follow or be followed</p>

data/app/views/federails/client/followings/_follow_actions.html.erb

@@ -10,7 +10,7 @@
     <% if actor.entity == user %>
       <button type="button" role="button" disabled="disabled">That's you</button>
     <% elsif follow %>
-      Already following (<%= follow.status %>)
+      You are already following (<%= follow.status %>)
       <%= button_to 'Cancel', federails.client_following_path(follow), method: :delete %>
     <% else %>
       <%= button_to "Follow #{actor.username}", federails.follow_client_followings_path, params: { account: actor.at_address }, method: :post %>
@@ -26,6 +26,10 @@
         <%= button_to 'Revoke', federails.client_following_path(followed), method: :delete %>
       <% end %>
     <% end %>
+  <% elsif !user %>
+    Register or login to be able to follow this actor. Alternatively, search for this address on Fediverse server where
+    you already have an account:
+    <input type="text" readonly="readonly" value="<%= actor.at_address(prefix: '') %>">
   <% else %>
     <%= user.class.name %> is not configured to follow/be followed, or has no associated actor.
   <% end %>