federails 0.5.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9e6d475999161590317e4a038b44829fdae2a44ccb007b03f24c240fccfa0771
-  data.tar.gz: b2266e7c4e9ac8c68177e2b17fc2e74afab52fc0e93607943716e06b39c10f6d
+  metadata.gz: '0538a0c2d7f7e3845a5d8ae304ac2b319b3cf1e76b10520645773f8f763c3431'
+  data.tar.gz: e97c559ecc5aba1b1c05c9be5f39b982a22e92cb8f73ae8c8a08741a3efb3d01
 SHA512:
-  metadata.gz: 14c482129bac20d5dfdaa2fa498070ab215819a0fe6af6499e268d631f40a7c15ee3341e999e6b0bfee5fd997b7a41f879c35537aeebbfbbdfc6182289d5edf4
-  data.tar.gz: 0c6fe55888c7b31f93958e258ad4b137aa305269056b2b512af2a137e2a15ac6de36a0a83f7fbec436c6657fca3c4ad9c18c08bb46a93e48601ef226c9a0011c
+  metadata.gz: 560377c5b698b87274d1df302595c33467f010402096227583161087aaf124b0a9e2820f44234b2932c158e84b0ab8ccb79ea8501557840509a416c7b8205295
+  data.tar.gz: 6380fc79556446afbd4a81e3e5e2e6b49bdb5877576dd1038208c1c4471cd3986bb35bbfaae1a9f37e618ddf5ab14dcf6974f512f6a609c70c2de0b7c251803f

data/README.md

@@ -23,12 +23,37 @@ The general direction is to be able to:
 - implement some or all the parts of the RFC labelled with **SHOULD** and **SHOULD NOT**
 - maybe implement the parts of the RFC labelled with **MAY**
 
+## Supported Ruby on Rails versions
+
+This gem is tested against non end-of-life versions of Ruby and Rails:
+
+- Ruby versions 3.1 to 3.4
+- Rails 7.1 to 8.0.x.
+
+Feel free to open an issue if we missed something
+
+It _may_ work on other versions, but we won't provide support.
+
 ## Documentation
 
 - [Usage](docs/usage.md)
 - [Common questions](docs/faq.md)
-- [Contributing](docs/contributing.md)
+- [Contributing](CONTRIBUTING.md)
 
 ## License
 
 The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+## Contributing
+
+See [CONTRIBUTING](CONTRIBUTING.md) to have an overview of the process and the tools we use.
+
+### Contributors
+
+- [echarp](https://gitlab.com/echarp)
+- [James Smith](https://gitlab.com/floppy.uk)
+- [Manuel Tancoigne](https://gitlab.com/mtancoigne)
+
+### Indirect contributions
+
+- Gitlab runners are graciously provided by [Coopaname](https://coopaname.coop), a French cooperative.

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

@@ -14,14 +14,16 @@ module Federails
 
       # GET /app/actors/1
       # GET /app/actors/1.json
-      def show; end
+      def show
+        render_show
+      end
 
-      # GET /app/explorer/lookup
-      # GET /app/explorer/lookup.json
+      # GET /app/actors/lookup
+      # GET /app/actors/lookup.json
       def lookup
         @actor = Federails::Actor.find_by_account account_param
         authorize @actor, policy_class: Federails::Client::ActorPolicy
-        render :show
+        render_show
       end
 
       private
@@ -35,6 +37,18 @@ module Federails
       def account_param
         params.require('account')
       end
+
+      def render_show
+        respond_to do |format|
+          if @actor.tombstoned?
+            format.html { render :gone, status: :gone }
+            format.json { render json: { error: I18n.t('controller.actors.gone') }, status: :gone }
+          else
+            format.html { render :show }
+            format.json { render :show }
+          end
+        end
+      end
     end
   end
 end

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

@@ -5,7 +5,10 @@ module Federails
 
       # GET /federation/actors/1
       # GET /federation/actors/1.json
-      def show; end
+      def show
+        status = @actor.tombstoned? ? :gone : :ok
+        render :show, status: status
+      end
 
       # GET /federation/actors/:id/followers
       # GET /federation/actors/:id/followers.json

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

@@ -3,7 +3,7 @@ module Federails
     # Controller to render ActivityPub representation of entities configured with Federails::DataEntity
     class PublishedController < Federails::ServerController
       def show
-        @publishable = type_scope.find_by!(url_param => params[:id])
+        @publishable = type_scope.find_untombstoned_by!(url_param => params[:id])
         authorize @publishable, policy_class: Federails::Server::PublishablePolicy
       end
 

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

@@ -9,11 +9,12 @@ module Federails
         resource = params.require(:resource)
         case resource
         when %r{^https?://.+}
-          @user = Federails::Actor.find_by_federation_url(resource)&.entity
+          @user = Federails::Actor.find_by_federation_url!(resource).entity # rubocop:disable Rails/DynamicFindBy
         when /^acct:.+/
-          Federails::Configuration.actor_types.each_value do |entity|
-            @user ||= entity[:class].find_by(entity[:username_field] => username)
-          end
+          actor = Federails::Actor.find_local_by_username(username)
+          raise Federails::Actor::TombstonedError if actor&.tombstoned?
+
+          @user = actor&.entity
         end
         raise ActiveRecord::RecordNotFound if @user.nil?
 
@@ -31,11 +32,13 @@ module Federails
       private
 
       def username
-        account = Fediverse::Webfinger.split_resource_account params.require(:resource)
+        return @username if instance_variable_defined? :@username
+
+        account = Fediverse::Webfinger.split_account params.require(:resource)
         # Fail early if user don't _seems_ local
         raise ActiveRecord::RecordNotFound unless account && Fediverse::Webfinger.local_user?(account)
 
-        account[:username]
+        @username = account[:username]
       end
     end
   end

data/app/controllers/federails/server_controller.rb

@@ -8,6 +8,9 @@ module Federails
     helper Federails::ServerHelper
 
     rescue_from ActiveRecord::RecordNotFound, with: :error_not_found
+    rescue_from Federails::Actor::TombstonedError,
+                Federails::DataEntity::TombstonedError,
+                with: :error_gone
 
     private
 
@@ -26,5 +29,9 @@ module Federails
     def error_not_found(exception = nil)
       error_fallback(exception, 'Resource not found', :not_found)
     end
+
+    def error_gone(exception = nil)
+      error_fallback(exception, 'Resource is gone', :gone)
+    end
   end
 end

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

@@ -59,14 +59,26 @@ module Federails
       end
       # rubocop:enable Metrics/ParameterLists
 
-      # Define a method that will be called after the entity receives a follow request
+      # Define a method that will be called after the entity receives a follow request.
+      # The follow request will be passed as an argument to the method.
       #
       # @param method_name [Symbol] The name of the method to call, or a block that will be called directly
       #
       # @example
       #   after_followed :accept_follow
       def after_followed(method_name)
-        set_callback :followed, :after, method_name
+        @after_followed = method_name
+      end
+
+      # Define a method that will be called after a follow request made by the entity is accepted
+      # The accepted follow request will be passed as an argument to the method.
+      #
+      # @param method_name [Symbol] The name of the method to call, or a block that will be called directly
+      #
+      # @example
+      #   after_follow_accepted :follow_accepted
+      def after_follow_accepted(method_name)
+        @after_follow_accepted = method_name
       end
 
       # Define a method that will be called after an activity has been received
@@ -80,20 +92,29 @@ module Federails
       def after_activity_received(activity_type, object_type, method_name)
         Fediverse::Inbox.register_handler(activity_type, object_type, self, method_name)
       end
-    end
 
-    included do
-      include ActiveSupport::Callbacks
+      private
 
-      define_callbacks :followed
+      def dispatch_callback(name, instance, *args)
+        case name
+        when :after_followed
+          instance.send(@after_followed, *args) if @after_followed
+        when :after_follow_accepted
+          instance.send(@after_follow_accepted, *args) if @after_follow_accepted
+        end
+      end
+    end
 
-      has_one :federails_actor, class_name: 'Federails::Actor', as: :entity, dependent: :destroy
+    included do
+      # No "dependent: :xyz" as the "before_destroy" hook should have nullified the actor
+      has_one :federails_actor, class_name: 'Federails::Actor', as: :entity # rubocop:disable Rails/HasManyOrHasOneDependent
 
       after_create :create_federails_actor, if: lambda {
         raise("Entity not configured for #{self.class.name}. Did you use \"acts_as_federails_actor\"?") unless Federails.actor_entity? self
 
         Federails.actor_entity(self)[:auto_create_actors]
       }
+      before_destroy :tombstone_federails_actor!
     end
 
     # Add custom data to actor responses.
@@ -123,8 +144,19 @@ module Federails
 
     private
 
+    # Result is used to determine if an actor related to this entity should be created as local actor or not
+    #
+    # Override it in your models if you need distant actors to be related to another entity.
+    def create_federails_actor_as_local?
+      true
+    end
+
     def create_federails_actor
-      Federails::Actor.create! entity: self
+      Federails::Actor.create_with(local: create_federails_actor_as_local?).find_or_create_by!(entity: self)
+    end
+
+    def tombstone_federails_actor!
+      federails_actor.tombstone!
     end
   end
 end

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

@@ -25,10 +25,17 @@ module Federails
   # class Post < ApplicationRecord
   #   include Federails::DataEntity
   #   acts_as_federails_data options
+  #
+  #   # 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
   # end
   # ```
   module DataEntity
+    class TombstonedError < StandardError; end
+
     extend ActiveSupport::Concern
+    include Federails::HandlesDeleteRequests
 
     # Class methods automatically included in the concern.
     module ClassMethods
@@ -49,10 +56,14 @@ 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_delete_date_method [Symbol, nil] Method to get the date of the soft-deletion
       #
       # @example
       #   acts_as_federails_data handles: 'Note', with: :note_handler, route_path_segment: :articles, actor_entity_method: :user
-      # rubocop:disable Metrics/ParameterLists
+      # rubocop:disable Metrics/ParameterLists, Metrics/MethodLength
       def acts_as_federails_data(
         handles:,
         with: :handle_incoming_fediverse_data,
@@ -60,23 +71,28 @@ module Federails
         actor_entity_method: nil,
         url_param: :id,
         filter_method: nil,
-        should_federate_method: :default_should_federate?
+        should_federate_method: :default_should_federate?,
+        soft_deleted_method: nil,
+        soft_delete_date_method: nil
       )
         route_path_segment ||= name.pluralize.underscore
 
         Federails::Configuration.register_data_type self,
-                                                    route_path_segment:     route_path_segment,
-                                                    actor_entity_method:    actor_entity_method,
-                                                    url_param:              url_param,
-                                                    handles:                handles,
-                                                    with:                   with,
-                                                    filter_method:          filter_method,
-                                                    should_federate_method: should_federate_method
-
+                                                    route_path_segment:      route_path_segment,
+                                                    actor_entity_method:     actor_entity_method,
+                                                    url_param:               url_param,
+                                                    handles:                 handles,
+                                                    with:                    with,
+                                                    filter_method:           filter_method,
+                                                    should_federate_method:  should_federate_method,
+                                                    soft_deleted_method:     soft_deleted_method,
+                                                    soft_delete_date_method: soft_delete_date_method
+
+        # NOTE: Delete activities cannot be handled like this as we can't be sure to have the object's type
         Fediverse::Inbox.register_handler 'Create', handles, self, with
         Fediverse::Inbox.register_handler 'Update', handles, self, with
       end
-      # rubocop:enable Metrics/ParameterLists
+      # rubocop:enable Metrics/ParameterLists, Metrics/MethodLength
 
       # Instantiates a new instance from an ActivityPub object
       #
@@ -107,6 +123,15 @@ module Federails
 
         entity
       end
+
+      def find_untombstoned_by!(**params)
+        configuration = Federails.data_entity_configuration(self)
+        entity = find_by!(**params)
+
+        raise Federails::DataEntity::TombstonedError if configuration[:soft_deleted_method] && entity.send(configuration[:soft_deleted_method])
+
+        entity
+      end
     end
 
     included do
@@ -116,8 +141,9 @@ module Federails
       scope :distant_federails_entities, -> { where.not(federated_url: nil) }
 
       before_validation :set_federails_actor
-      after_create :create_federails_activity
-      after_update :update_federails_activity
+      after_create -> { create_federails_activity 'Create' }
+      after_update -> { create_federails_activity 'Update' }, :federails_tombstoned?
+      after_destroy -> { create_federails_activity 'Delete' }
     end
 
     # Computed value for the federated URL
@@ -139,6 +165,14 @@ module Federails
       attributes['federated_url'].blank?
     end
 
+    def federails_tombstoned?
+      federails_data_configuration[:soft_deleted_method] ? send(federails_data_configuration[:soft_deleted_method]) : false
+    end
+
+    def federails_tombstoned_at
+      federails_data_configuration[:soft_delete_date_method] ? send(federails_data_configuration[:soft_delete_date_method]) : nil
+    end
+
     def federails_data_configuration
       Federails.data_entity_configuration(self)
     end
@@ -153,18 +187,11 @@ module Federails
       raise 'Cannot determine actor from configuration' unless federails_actor
     end
 
-    def create_federails_activity
-      ensure_federails_configuration!
-      return unless local_federails_entity? && send(federails_data_configuration[:should_federate_method])
-
-      Activity.create! actor: federails_actor, action: 'Create', entity: self
-    end
-
-    def update_federails_activity
+    def create_federails_activity(action)
       ensure_federails_configuration!
       return unless local_federails_entity? && send(federails_data_configuration[:should_federate_method])
 
-      Activity.create! actor: federails_actor, action: 'Update', entity: self
+      Activity.create! actor: federails_actor, action: action, entity: self
     end
 
     def ensure_federails_configuration!

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

@@ -0,0 +1,31 @@
+module Federails
+  # Model concern providing hooks for on_federails_delete_requested callback
+  #
+  # ```rb
+  # # Example migration
+  # add_column :my_table, :uuid, :text, default: nil, index: { unique: true }
+  # ```
+  #
+  # Usage:
+  #
+  # ```rb
+  # class MyModel < ApplicationRecord
+  #   include Federails::HandlesDeleteRequests
+  #
+  #   on_federails_delete_requested -> { delete! }
+  # end
+  module HandlesDeleteRequests
+    extend ActiveSupport::Concern
+
+    # Class methods automatically included in the concern.
+    module ClassMethods
+      def on_federails_delete_requested(*args)
+        set_callback :on_federails_delete_requested, *args
+      end
+    end
+
+    included do
+      define_callbacks :on_federails_delete_requested
+    end
+  end
+end

data/app/models/federails/activity.rb

@@ -30,16 +30,27 @@ module Federails
     def recipients
       return [] unless actor.local?
 
-      case entity_type
-      when 'Federails::Following'
-        [(action == 'Accept' ? entity.actor : entity.target_actor)]
+      case action
+      when 'Follow'
+        [entity]
+      when 'Undo'
+        [entity.entity]
+      when 'Accept'
+        [entity.actor]
       else
-        actor.followers
+        default_recipient_list
       end
     end
 
     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
+    end
+
     def post_to_inboxes
       NotifyInboxJob.perform_later(self)
     end

data/app/models/federails/actor.rb

@@ -1,4 +1,5 @@
 require 'federails/utils/host'
+require 'federails/utils/actor'
 require 'fediverse/webfinger'
 
 module Federails
@@ -9,17 +10,22 @@ module Federails
   # See also:
   #  - https://www.w3.org/TR/activitypub/#actor-objects
   class Actor < ApplicationRecord # rubocop:disable Metrics/ClassLength
-    include Federails::HasUuid
+    class TombstonedError < StandardError; end
 
-    validates :federated_url, presence: { unless: :entity }, uniqueness: { unless: :entity }
-    validates :username, presence: { unless: :entity }
-    validates :server, presence: { unless: :entity }
-    validates :inbox_url, presence: { unless: :entity }
-    validates :outbox_url, presence: { unless: :entity }
-    validates :followers_url, presence: { unless: :entity }
-    validates :followings_url, presence: { unless: :entity }
-    validates :profile_url, presence: { unless: :entity }
-    validates :entity_id, uniqueness: { scope: :entity_type }, if: :local?
+    include Federails::HasUuid
+    include Federails::HandlesDeleteRequests
+
+    validates :federated_url, presence: { unless: :entity }, uniqueness: { unless: :local? }
+    validates :username, presence: { unless: :local? }
+    validates :server, presence: { unless: :local? }
+    validates :inbox_url, presence: { unless: :local? }
+    validates :outbox_url, presence: { unless: :local? }
+    validates :followers_url, presence: { unless: :local? }
+    validates :followings_url, presence: { unless: :local? }
+    validates :profile_url, presence: { unless: :local? }
+    validates :actor_type, presence: { unless: :local? }
+    validates :entity_id, uniqueness: { scope: :entity_type }, if: :entity_type
+    validates :entity, presence: true, if: -> { local? && !tombstoned? }
 
     belongs_to :entity, polymorphic: true, optional: true
     # FIXME: Handle this with something like undelete
@@ -30,51 +36,59 @@ module Federails
     has_many :followers, source: :actor, through: :following_followers
     has_many :follows, source: :target_actor, through: :following_follows
 
-    scope :local, -> { where.not(entity: nil) }
-    scope :distant, -> { where.not(federated_url: nil) }
+    scope :local, -> { where(local: true) }
+    scope :distant, -> { where(local: false) }
+    scope :tombstoned, -> { where.not(tombstoned_at: nil) }
+    scope :not_tombstoned, -> { where(tombstoned_at: nil) }
 
-    def local?
-      entity.present?
+    on_federails_delete_requested -> { tombstone! }
+
+    def distant?
+      !local?
     end
 
     def federated_url
-      local? ? Federails::Engine.routes.url_helpers.server_actor_url(self) : attributes['federated_url'].presence
+      use_entity_attributes? ? Federails::Engine.routes.url_helpers.server_actor_url(self) : attributes['federated_url'].presence
     end
 
     def username
-      return attributes['username'] unless local?
+      return attributes['username'] unless use_entity_attributes?
 
       entity.send(entity_configuration[:username_field]).to_s
     end
 
     def name
-      value = (entity.send(entity_configuration[:name_field]).to_s if local?)
+      value = (entity.send(entity_configuration[:name_field]).to_s if use_entity_attributes?)
 
       value || attributes['name'] || username
     end
 
     def server
-      local? ? Utils::Host.localhost : attributes['server']
+      use_entity_attributes? ? Utils::Host.localhost : attributes['server']
+    end
+
+    def actor_type
+      use_entity_attributes? ? entity_configuration[:actor_type] : attributes['actor_type']
     end
 
     def inbox_url
-      local? ? Federails::Engine.routes.url_helpers.server_actor_inbox_url(self) : attributes['inbox_url']
+      use_entity_attributes? ? Federails::Engine.routes.url_helpers.server_actor_inbox_url(self) : attributes['inbox_url']
     end
 
     def outbox_url
-      local? ? Federails::Engine.routes.url_helpers.server_actor_outbox_url(self) : attributes['outbox_url']
+      use_entity_attributes? ? Federails::Engine.routes.url_helpers.server_actor_outbox_url(self) : attributes['outbox_url']
     end
 
     def followers_url
-      local? ? Federails::Engine.routes.url_helpers.followers_server_actor_url(self) : attributes['followers_url']
+      use_entity_attributes? ? Federails::Engine.routes.url_helpers.followers_server_actor_url(self) : attributes['followers_url']
     end
 
     def followings_url
-      local? ? Federails::Engine.routes.url_helpers.following_server_actor_url(self) : attributes['followings_url']
+      use_entity_attributes? ? Federails::Engine.routes.url_helpers.following_server_actor_url(self) : attributes['followings_url']
     end
 
     def profile_url
-      return attributes['profile_url'].presence unless local?
+      return attributes['profile_url'].presence unless use_entity_attributes?
 
       method = entity_configuration[:profile_url_method]
       return Federails::Engine.routes.url_helpers.server_actor_url self unless method
@@ -83,11 +97,15 @@ module Federails
     end
 
     def at_address
-      "#{username}@#{server}"
+      "@#{username}@#{server}"
     end
 
     def short_at_address
-      local? ? "@#{username}" : at_address
+      use_entity_attributes? ? "@#{username}" : at_address
+    end
+
+    def acct_uri
+      "acct:#{username}@#{server}"
     end
 
     def follows?(actor)
@@ -103,16 +121,24 @@ module Federails
       Federails.actor_entity entity_type
     end
 
+    def tombstoned?
+      tombstoned_at.present?
+    end
+
+    def tombstone!
+      Federails::Utils::Actor.tombstone! self
+    end
+
     class << self
-      def find_by_account(account) # rubocop:todo Metrics/AbcSize
+      # Searches for an actor from account URI
+      #
+      # @param account [String] Account URI (username@host)
+      # @return [Federails::Actor, nil]
+      def find_by_account(account)
         parts = Fediverse::Webfinger.split_account account
 
         if Fediverse::Webfinger.local_user? parts
-          actor = nil
-          Federails::Configuration.actor_types.each_value do |entity|
-            actor ||= entity[:class].find_by(entity[:username_field] => parts[:username])&.federails_actor
-          end
-          raise ActiveRecord::RecordNotFound if actor.nil?
+          actor = find_local_by_username! parts[:username]
         else
           actor = find_by username: parts[:username], server: parts[:domain]
           actor ||= Fediverse::Webfinger.fetch_actor(parts[:username], parts[:domain])
@@ -131,6 +157,13 @@ module Federails
         Fediverse::Webfinger.fetch_actor_url(federated_url)
       end
 
+      def find_by_federation_url!(federated_url)
+        find_by_federation_url(federated_url).tap do |actor|
+          raise Federails::Actor::TombstonedError if actor.tombstoned?
+          raise ActiveRecord::RecordNotFound if actor.nil?
+        end
+      end
+
       def find_or_create_by_account(account)
         actor = find_by_account account
         # Create/update distant actors
@@ -158,6 +191,25 @@ module Federails
           raise "Unsupported object type for actor (#{object.class})"
         end
       end
+
+      def find_local_by_username(username)
+        actor = nil
+        Federails::Configuration.actor_types.each_value do |entity|
+          break if actor.present?
+
+          actor = entity[:class].find_by(entity[:username_field] => username)&.federails_actor
+        end
+        return actor if actor
+
+        # Last hope: Search for tombstoned actors
+        Federails::Actor.local.tombstoned.find_by username: username
+      end
+
+      def find_local_by_username!(username)
+        find_local_by_username(username).tap do |actor|
+          raise ActiveRecord::RecordNotFound if actor.nil?
+        end
+      end
     end
 
     def public_key
@@ -194,5 +246,9 @@ module Federails
         public_key:  rsa_key.public_key.to_pem,
       }
     end
+
+    def use_entity_attributes?
+      local? && !tombstoned?
+    end
   end
 end