fedipub 0.0.1 → 0.9.0

data/app/jobs/fedipub/notify_inbox_job.rb

@@ -0,0 +1,10 @@
+require 'fediverse/notifier'
+
+module Fedipub
+  class NotifyInboxJob < ApplicationJob
+    def perform(activity)
+      activity.reload
+      Fediverse::Notifier.post_to_inboxes(activity)
+    end
+  end
+end

data/app/mailers/fedipub/application_mailer.rb

@@ -0,0 +1,6 @@
+module Fedipub
+  class ApplicationMailer < ActionMailer::Base
+    default from: 'from@example.com'
+    layout 'mailer'
+  end
+end

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

@@ -0,0 +1,166 @@
+module Fedipub
+  # Concern to include in models that acts as actors.
+  #
+  # Actors can be anything; they authors content _via_ their _outbox_ and receive content in their _inbox_.
+  # Actors can follow and be followed by each other
+  #
+  # By default, when an entry is created on models using this concern, a _local_ `Fedipub::Actor` will be created.
+  #
+  # See also:
+  #  - https://www.w3.org/TR/activitypub/#actor-objects
+  #
+  # ## Usage
+  #
+  # Include the concern in an existing model:
+  #
+  # ```rb
+  # class User < ApplicationRecord
+  #   include Fedipub::ActorEntity
+  #   acts_as_fedipub_actor options
+  # end
+  # ```
+  module ActorEntity
+    extend ActiveSupport::Concern
+
+    # Class methods automatically included in the concern.
+    module ClassMethods
+      # Configures the mapping between entity and actor
+      #
+      # @param username_field [Symbol] The method or attribute name that returns the preferred username for ActivityPub
+      # @param name_field [Symbol] The method or attribute name that returns the preferred name for ActivityPub
+      # @param profile_url_method [Symbol] The route method name that will generate the profile URL for ActivityPub
+      # @param actor_type [String] The ActivityStreams Actor type for this entity; defaults to 'Person'
+      # @param user_count_method [Symbol] A class method to call to count active users. Leave unspecified to leave this
+      #   entity out of user counts. Method signature should accept a single parameter which will specify a date range
+      #   If parameter is nil, the total user count should be returned. If the parameter is specified, the number of users
+      #   active during the time period should be returned.
+      # @param auto_create_actors [Boolean] Whether to automatically create an actor when the entity is created
+      #
+      # @example
+      #   acts_as_fedipub_actor username_field: :username, name_field: :display_name, profile_url_method: :url_for, actor_type: 'Person'
+      # rubocop:disable Metrics/ParameterLists
+      def acts_as_fedipub_actor(
+        name_field:,
+        username_field:,
+        profile_url_method: nil,
+        actor_type: 'Person',
+        user_count_method: nil,
+        auto_create_actors: true
+      )
+        Fedipub::Configuration.register_actor_class(
+          self,
+          username_field:     username_field,
+          name_field:         name_field,
+          profile_url_method: profile_url_method,
+          actor_type:         actor_type,
+          user_count_method:  user_count_method,
+          auto_create_actors: auto_create_actors
+        )
+      end
+      # rubocop:enable Metrics/ParameterLists
+
+      # 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)
+        @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
+      #
+      # @param activity_type [String] The activity action to handle, e.g. 'Create'. If you specify '*', the handler will be called for any activity type.
+      # @param object_type [String] The object type to handle, e.g. 'Note'. If you specify '*', the handler will be called for any object type.
+      # @param method_name [Symbol] The name of the class method to call. The method will receive the complete activity payload as a parameter.
+      #
+      # @example
+      #   after_activity_received 'Create', 'Note', :create_note
+      def after_activity_received(activity_type, object_type, method_name)
+        Fediverse::Inbox.register_handler(activity_type, object_type, self, method_name)
+      end
+
+      private
+
+      def dispatch_callback(name, instance, *)
+        case name
+        when :after_followed
+          instance.send(@after_followed, *) if @after_followed
+        when :after_follow_accepted
+          instance.send(@after_follow_accepted, *) if @after_follow_accepted
+        end
+      end
+    end
+
+    included do
+      # No "dependent: :xyz" as the "before_destroy" hook should have nullified the actor
+      has_one :fedipub_actor, class_name: 'Fedipub::Actor', as: :entity # rubocop:disable Rails/HasManyOrHasOneDependent
+
+      after_create :create_fedipub_actor, if: lambda {
+        raise("Entity not configured for #{self.class.name}. Did you use \"acts_as_fedipub_actor\"?") unless Fedipub.actor_entity? self
+
+        Fedipub.actor_entity(self)[:auto_create_actors]
+      }
+      before_destroy :tombstone_fedipub_actor!
+    end
+
+    # Add custom data to actor responses.
+    #
+    # Override in your own model to add extra data, which will be merged into the actor response
+    # generated by Fedipub. You can include extra `@context` for activitypub extensions and it will
+    # be merged with the main response context.
+    #
+    # @example
+    #   def to_activitypub_object
+    #     {
+    #       "@context": {
+    #         toot: "http://joinmastodon.org/ns#",
+    #         attributionDomains: {
+    #           "@id": "toot:attributionDomains",
+    #           "@type": "@id"
+    #         }
+    #       },
+    #       attributionDomains: [
+    #         "example.com"
+    #       ]
+    #     }
+    #   end
+    def to_activitypub_object
+      {}
+    end
+
+    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_fedipub_actor_as_local?
+      true
+    end
+
+    def create_fedipub_actor
+      Fedipub::Actor.create_with(local: create_fedipub_actor_as_local?).find_or_create_by!(entity: self)
+    end
+
+    def tombstone_fedipub_actor!
+      fedipub_actor.presence&.tombstone!
+    end
+
+    def untombstone_fedipub_actor!
+      fedipub_actor.presence&.untombstone!
+    end
+  end
+end

data/app/models/concerns/fedipub/announceable.rb

@@ -0,0 +1,18 @@
+module Fedipub
+  module Announceable
+    extend ActiveSupport::Concern
+
+    # Announces (boosts) this entity by creating a new Activity.
+    #
+    # @param actor [Fedipub::Actor] The actor doing the announce; defaults to the entity's own actor.
+    #
+    # @return [Fedipub::Activity] the newly-created Announce activity
+    def announce!(actor: nil)
+      actor ||= try(:fedipub_actor) || self
+      create_fedipub_activity('Announce',
+                              actor: actor,
+                              to:    [Fediverse::Collection::PUBLIC],
+                              cc:    [actor.followers_url])
+    end
+  end
+end

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

@@ -0,0 +1,279 @@
+require 'fediverse/inbox'
+
+module Fedipub
+  # Model concern to include in models for which data is pushed to the Fediverse and comes from the Fediverse.
+  #
+  # Once included, an activity will automatically be created upon
+  #   - entity creation
+  #   - entity updates
+  #
+  # Also, when properly configured, a handler is registered to transform incoming objects and create/update entities
+  # accordingly.
+  #
+  # ## Pre-requisites
+  #
+  # 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 :fedipub_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, :fedipub_actor, foreign_key: true, null: true, default: nil
+  # ```
+  #
+  # ## Usage
+  #
+  # Include the concern in an existing model:
+  #
+  # ```rb
+  # class Post < ApplicationRecord
+  #   include Fedipub::DataEntity
+  #   acts_as_fedipub_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_fedipub_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_fedipub_undelete_requested :do_something_else
+  #
+  #   def to_activitypub_object
+  #     Fedipub::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 Fedipub responses:
+  # - you will need to send the delete activity yourself
+  #
+  # ```rb
+  # acts_as_fedipub_data handles: 'Note',
+  #                        ...,
+  #                        soft_deleted_method: :deleted?
+  #                        soft_delete_date_method: :deleted_at
+  #
+  # on_fedipub_delete_requested :soft_delete!
+  # on_fedipub_undelete_requested :restore_remote_entity!
+  #
+  # # Method you use to soft-delete entities
+  # def soft_delete!
+  #   update deleted_at: time.current
+  #
+  #   send_fedipub_activity 'Delete' unless local_fedipub_entity?
+  # end
+  #
+  # # Method you use to restore soft-deleted entities
+  # def restore!
+  #   update deleted_at: nil
+  #
+  #   if local_fedipub_entity?
+  #     delete_activity =  Activity.find_by action: 'Delete', entity: self
+  #     send_fedipub_activity 'Undo', entity: delete_activity, actor: fedipub_actor if delete_activity.present?
+  #   end
+  # end
+  #
+  # def restore_remote_entity!
+  #   self.deleted_at: nil
+  #   fedipub_sync!
+  #   save!
+  # end
+  # ```
+  module DataEntity
+    class TombstonedError < StandardError; end
+
+    extend ActiveSupport::Concern
+    include Fedipub::HandlesDeleteRequests
+    include Fedipub::Likeable
+    include Fedipub::Announceable
+
+    # Class methods automatically included in the concern.
+    module ClassMethods
+      # Configures the mapping between entity and Fediverse
+      #
+      # @param actor_entity_method [Symbol] Method returning an object responding to 'fedipub_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 Fedipub routes to display the ActivityPub representation.
+      #   Defaults to the pluralized, underscored class name
+      # @param handles [String] Type of ActivityPub object handled by this entity type
+      # @param with [Symbol] Self class method that will handle incoming objects. Defaults to +:handle_incoming_fediverse_data+
+      # @param filter_method [Symbol] Self class method that determines if an incoming object should be handled. Note
+      #   that the first model for which this method returns true will be used. If left empty, the model CAN be selected,
+      #   so define them if many models handle the same data type.
+      # @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] 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
+      #   acts_as_fedipub_data handles: 'Note', with: :note_handler, route_path_segment: :articles, actor_entity_method: :user
+      # rubocop:disable Metrics/ParameterLists, Metrics/MethodLength
+      def acts_as_fedipub_data(
+        handles:,
+        with: :handle_incoming_fediverse_data,
+        route_path_segment: nil,
+        actor_entity_method: nil,
+        url_param: :id,
+        filter_method: nil,
+        should_federate_method: :default_should_federate?,
+        soft_deleted_method: nil,
+        soft_delete_date_method: nil
+      )
+        route_path_segment ||= name.pluralize.underscore
+
+        Fedipub::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,
+                                                  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, Metrics/MethodLength
+
+      # Instantiates a new instance from an ActivityPub object
+      #
+      # @param activitypub_object [Hash]
+      #
+      # @return [self]
+      def new_from_activitypub_object(activitypub_object)
+        new from_activitypub_object(activitypub_object)
+      end
+
+      # Creates or updates entity based on the ActivityPub activity
+      #
+      # @param activity_hash_or_id [Hash, String] Dereferenced activity hash or ID
+      #
+      # @return [self]
+      def handle_incoming_fediverse_data(activity_hash_or_id)
+        activity = Fediverse::Request.dereference(activity_hash_or_id)
+        object = Fediverse::Request.dereference(activity['object'])
+
+        entity = Fedipub::Utils::Object.find_or_create!(object)
+
+        if activity['type'] == 'Update'
+          entity.assign_attributes from_activitypub_object(object)
+
+          # Use timestamps from attributes
+          entity.save! touch: false
+        end
+
+        entity
+      end
+
+      def find_untombstoned_by!(**params)
+        configuration = Fedipub.data_entity_configuration(self)
+        entity = find_by!(**params)
+
+        raise Fedipub::DataEntity::TombstonedError if configuration[:soft_deleted_method] && entity.send(configuration[:soft_deleted_method])
+
+        entity
+      end
+    end
+
+    included do
+      belongs_to :fedipub_actor, class_name: 'Fedipub::Actor'
+
+      scope :local_fedipub_entities, -> { where federated_url: nil }
+      scope :distant_fedipub_entities, -> { where.not(federated_url: nil) }
+
+      before_validation :set_fedipub_actor
+      after_create -> { create_fedipub_activity 'Create' }
+      after_update -> { create_fedipub_activity 'Update' }, unless: :fedipub_tombstoned?
+      after_destroy -> { create_fedipub_activity 'Delete' }
+    end
+
+    # Computed value for the federated URL
+    #
+    # @return [String]
+    def federated_url
+      return nil unless send(fedipub_data_configuration[:should_federate_method])
+      return attributes['federated_url'] if attributes['federated_url'].present?
+
+      path_segment = Fedipub.data_entity_configuration(self)[:route_path_segment]
+      url_param = Fedipub.data_entity_configuration(self)[:url_param]
+      Fedipub::Engine.routes.url_helpers.server_published_url(publishable_type: path_segment, id: send(url_param))
+    end
+
+    # Check whether the entity was created locally or comes from the Fediverse
+    #
+    # @return [Boolean]
+    def local_fedipub_entity?
+      attributes['federated_url'].blank?
+    end
+
+    def fedipub_tombstoned?
+      fedipub_data_configuration[:soft_deleted_method] ? send(fedipub_data_configuration[:soft_deleted_method]) : false
+    end
+
+    def fedipub_tombstoned_at
+      fedipub_data_configuration[:soft_delete_date_method] ? send(fedipub_data_configuration[:soft_delete_date_method]) : nil
+    end
+
+    def fedipub_data_configuration
+      Fedipub.data_entity_configuration(self)
+    end
+
+    def fedipub_sync!
+      if local_fedipub_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_fedipub_actor
+      return fedipub_actor if fedipub_actor.present?
+
+      self.fedipub_actor = send(fedipub_data_configuration[:actor_entity_method])&.fedipub_actor if fedipub_data_configuration[:actor_entity_method]
+
+      raise 'Cannot determine actor from configuration' unless fedipub_actor
+    end
+
+    def create_fedipub_activity(action, actor: fedipub_actor, to: nil, cc: nil)
+      ensure_fedipub_configuration!
+      return unless local_fedipub_entity? && send(fedipub_data_configuration[:should_federate_method])
+
+      Activity.create! actor: actor, action: action, entity: self, to: to, cc: cc
+    end
+
+    def ensure_fedipub_configuration!
+      raise("Entity not configured for #{self.class.name}. Did you use \"acts_as_fedipub_data\"?") unless Fedipub.data_entity? self
+    end
+
+    def default_should_federate?
+      true
+    end
+  end
+end

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

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

data/app/models/concerns/fedipub/has_uuid.rb

@@ -0,0 +1,61 @@
+module Fedipub
+  # Model concern providing UUIDs as model parameter (instead of IDs).
+  #
+  #
+  # A _required_, `uuid` field is required on the model's table for this concern to work:
+  #
+  # ```rb
+  # # Example migration
+  # add_column :my_table, :uuid, :text, default: nil, index: { unique: true }
+  # ```
+  #
+  # Usage:
+  #
+  # ```rb
+  # class MyModel < ApplicationRecord
+  #   include Fedipub::HasUuid
+  # end
+  #
+  # # And now:
+  # instance = MyModel.find_param 'aaaa_bbbb_cccc_dddd_....'
+  # instance.to_param
+  # # => 'aaaa_bbbb_cccc_dddd_....'
+  # ```
+  #
+  # It can be added on existing tables without data migration as the `uuid` accessor will generate the value when missing.
+  module HasUuid
+    extend ActiveSupport::Concern
+
+    included do
+      before_validation :generate_uuid
+      validates :uuid, presence: true, uniqueness: true
+
+      def self.find_param(param)
+        find_by!(uuid: param)
+      end
+    end
+
+    # @return [String] The UUID
+    def to_param
+      uuid
+    end
+
+    # @return [String]
+    def uuid
+      # Override UUID accessor to provide lazy initialization of UUIDs for old data
+      if self[:uuid].blank?
+        generate_uuid
+        save!
+      end
+      self[:uuid]
+    end
+
+    private
+
+    def generate_uuid
+      return if self[:uuid].present?
+
+      (self.uuid = SecureRandom.uuid) while self[:uuid].blank? || self.class.exists?(uuid: self[:uuid])
+    end
+  end
+end

data/app/models/concerns/fedipub/likeable.rb

@@ -0,0 +1,29 @@
+module Fedipub
+  module Likeable
+    extend ActiveSupport::Concern
+
+    # Likes this entity by creating a new Activity.
+    #
+    # @param actor [Fedipub::Actor] The actor that is doing the liking.
+    #
+    # @return [Fedipub::Activity] the newly-created Like activity
+    def like!(actor:)
+      create_fedipub_activity('Like',
+                              actor: actor,
+                              to:    [Fediverse::Collection::PUBLIC],
+                              cc:    [actor.followers_url])
+    end
+
+    # Dislikes this entity by creating a new Activity.
+    #
+    # @param actor [Fedipub::Actor] The actor that is doing the disliking.
+    #
+    # @return [Fedipub::Activity] the newly-created Dislike activity
+    def dislike!(actor:)
+      create_fedipub_activity('Dislike',
+                              actor: actor,
+                              to:    [Fediverse::Collection::PUBLIC],
+                              cc:    [actor.followers_url])
+    end
+  end
+end

data/app/models/fedipub/activity.rb

@@ -0,0 +1,62 @@
+module Fedipub
+  # Activities can be compared to a log of what happened in the Fediverse.
+  #
+  # Activities from local actors ends in the actors _outboxes_.
+  # Activities form distant actors comes from the actor's _inbox_.
+  # We try to only keep activities _from_ local actors, and external activities _targetting_ local actors.
+  #
+  # See also:
+  #   - https://www.w3.org/TR/activitypub/#outbox
+  #   - https://www.w3.org/TR/activitypub/#inbox
+  class Activity < ApplicationRecord
+    include Fedipub::HasUuid
+
+    belongs_to :entity, polymorphic: true
+    belongs_to :actor
+
+    scope :feed_for, lambda { |actor|
+      actor_ids = []
+      Following.accepted.where(actor: actor).find_each do |following|
+        actor_ids << following.target_actor_id
+      end
+      where(actor_id: actor_ids)
+    }
+
+    after_create_commit :post_to_inboxes
+
+    before_validation :set_default_addressing, on: :create
+
+    serialize :cc, coder: YAML
+    serialize :to, coder: YAML
+    serialize :result, coder: YAML
+    serialize :instrument, coder: YAML
+
+    # Sends an Undo activity to reverse this one.
+    #
+    # Used for unfollowing, unliking, unboosting, etc.
+    #
+    # @return [Fedipub::Activity] the new Undo activity
+    def undo!
+      Activity.create! actor: actor, action: 'Undo', entity: self, to: to, cc: cc
+    end
+
+    private
+
+    # 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
+      NotifyInboxJob.perform_later(self)
+    end
+  end
+end