federails 0.0.1 → 0.2.0

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

@@ -0,0 +1,57 @@
+module Federails
+  module Entity
+    extend ActiveSupport::Concern
+
+    included do # rubocop:todo Metrics/BlockLength
+      include ActiveSupport::Callbacks
+      define_callbacks :followed
+
+      # Define a method that will be called after the entity receives a follow request
+      # @param method [Symbol] The name of the method to call, or a block that will be called directly
+      # @example
+      #   after_followed :accept_follow
+      def self.after_followed(method)
+        set_callback :followed, :after, method
+      end
+
+      has_one :actor, class_name: 'Federails::Actor', as: :entity, dependent: :destroy
+
+      after_create :create_actor
+
+      # 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 include_in_user_count [boolean] Should this entity be included in the nodeinfo user count? Defaults to true
+      # @example
+      #   acts_as_federails_actor username_field: :username, name_field: :display_name, profile_url_method: :url_for, actor_type: 'Person'
+      def self.acts_as_federails_actor(
+        username_field: Federails::Configuration.user_username_field,
+        name_field: Federails::Configuration.user_name_field,
+        profile_url_method: Federails.configuration.user_profile_url_method,
+        actor_type: 'Person',
+        include_in_user_count: true
+      )
+        Federails::Configuration.register_entity(
+          self,
+          username_field:        username_field,
+          name_field:            name_field,
+          profile_url_method:    profile_url_method,
+          actor_type:            actor_type,
+          include_in_user_count: include_in_user_count
+        )
+      end
+
+      # Automatically run default acts_as_federails_actor
+      # this can be optionally called again with different configuration in the entity
+      acts_as_federails_actor
+
+      private
+
+      def create_actor
+        Federails::Actor.create! entity: self
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+module Federails
+  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
+
+    def to_param
+      uuid
+    end
+
+    # Override UUID accessor to provide lazy initialization of UUIDs for old data
+    def uuid
+      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/federails/activity.rb

@@ -0,0 +1,35 @@
+module Federails
+  class Activity < ApplicationRecord
+    include Federails::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
+
+    def recipients
+      return [] unless actor.local?
+
+      case entity_type
+      when 'Federails::Following'
+        [(action == 'Accept' ? entity.actor : entity.target_actor)]
+      else
+        actor.followers
+      end
+    end
+
+    private
+
+    def post_to_inboxes
+      NotifyInboxJob.perform_later(self)
+    end
+  end
+end

data/app/models/federails/actor.rb

@@ -0,0 +1,189 @@
+require 'federails/utils/host'
+require 'fediverse/webfinger'
+
+module Federails
+  class Actor < ApplicationRecord # rubocop:disable Metrics/ClassLength
+    include Federails::HasUuid
+
+    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?
+
+    belongs_to :entity, polymorphic: true, optional: true
+    # FIXME: Handle this with something like undelete
+    has_many :activities, dependent: :destroy
+    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
+    has_many :followers, source: :actor, through: :following_followers
+    has_many :follows, source: :target_actor, through: :following_follows
+
+    scope :local, -> { where.not(entity: nil) }
+
+    def local?
+      entity.present?
+    end
+
+    def federated_url
+      local? ? Federails::Engine.routes.url_helpers.server_actor_url(self) : attributes['federated_url'].presence
+    end
+
+    def username
+      return attributes['username'] unless local?
+
+      entity.send(entity_configuration[:username_field]).to_s
+    end
+
+    def name
+      value = (entity.send(entity_configuration[:name_field]).to_s if local?)
+
+      value || attributes['name'] || username
+    end
+
+    def server
+      local? ? Utils::Host.localhost : attributes['server']
+    end
+
+    def inbox_url
+      local? ? 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']
+    end
+
+    def followers_url
+      local? ? 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']
+    end
+
+    def profile_url
+      return attributes['profile_url'].presence unless local?
+
+      method = entity_configuration[:profile_url_method]
+      return Federails::Engine.routes.url_helpers.server_actor_url self unless method
+
+      Rails.application.routes.url_helpers.send method, [entity]
+    end
+
+    def at_address
+      "#{username}@#{server}"
+    end
+
+    def short_at_address
+      local? ? "@#{username}" : at_address
+    end
+
+    def follows?(actor)
+      list = following_follows.where target_actor: actor
+      return list.first if list.count == 1
+
+      false
+    end
+
+    def entity_configuration
+      Federails::Configuration.entity_types[entity.class.name]
+    end
+
+    class << self
+      def find_by_account(account) # rubocop:todo Metrics/AbcSize
+        parts = Fediverse::Webfinger.split_account account
+
+        if Fediverse::Webfinger.local_user? parts
+          actor = nil
+          Federails::Configuration.entity_types.each_value do |entity|
+            actor ||= entity[:class].find_by(entity[:username_field] => parts[:username])&.actor
+          end
+          raise ActiveRecord::RecordNotFound if actor.nil?
+        else
+          actor = find_by username: parts[:username], server: parts[:domain]
+          actor ||= Fediverse::Webfinger.fetch_actor(parts[:username], parts[:domain])
+        end
+
+        actor
+      end
+
+      def find_by_federation_url(federated_url)
+        local_route = Utils::Host.local_route federated_url
+        return find_param(local_route[:id]) if local_route && local_route[:controller] == 'federails/server/actors' && local_route[:action] == 'show'
+
+        actor = find_by federated_url: federated_url
+        return actor if actor
+
+        Fediverse::Webfinger.fetch_actor_url(federated_url)
+      end
+
+      def find_or_create_by_account(account)
+        actor = find_by_account account
+        # Create/update distant actors
+        actor.save! unless actor.local?
+
+        actor
+      end
+
+      def find_or_create_by_federation_url(url)
+        actor = find_by_federation_url url
+        # Create/update distant actors
+        actor.save! unless actor.local?
+
+        actor
+      end
+
+      # Find or create actor from a given actor hash or actor id (actor's URL)
+      def find_or_create_by_object(object)
+        case object
+        when String
+          find_or_create_by_federation_url object
+        when Hash
+          find_or_create_by_federation_url object['id']
+        else
+          raise "Unsupported object type for actor (#{object.class})"
+        end
+      end
+    end
+
+    def public_key
+      ensure_key_pair_exists!
+      self[:public_key]
+    end
+
+    def private_key
+      ensure_key_pair_exists!
+      self[:private_key]
+    end
+
+    def key_id
+      "#{federated_url}#main-key"
+    end
+
+    private
+
+    def ensure_key_pair_exists!
+      return if self[:private_key].present? || !local?
+
+      update!(generate_key_pair)
+    end
+
+    def generate_key_pair
+      rsa_key = OpenSSL::PKey::RSA.new 2048
+      cipher  = OpenSSL::Cipher.new('AES-128-CBC')
+      {
+        private_key: if Rails.application.credentials.secret_key_base
+                       rsa_key.to_pem(cipher, Rails.application.credentials.secret_key_base)
+                     else
+                       rsa_key.to_pem
+                     end,
+        public_key:  rsa_key.public_key.to_pem,
+      }
+    end
+  end
+end

data/app/models/federails/following.rb

@@ -0,0 +1,52 @@
+module Federails
+  class Following < ApplicationRecord
+    include Federails::HasUuid
+
+    enum status: { pending: 0, accepted: 1 }
+
+    validates :target_actor_id, uniqueness: { scope: [:actor_id, :target_actor_id] }
+
+    belongs_to :actor
+    belongs_to :target_actor, class_name: 'Federails::Actor'
+    # FIXME: Handle this with something like undelete
+    has_many :activities, as: :entity, dependent: :destroy
+
+    after_create :after_follow
+    after_create :create_activity
+    after_destroy :destroy_activity
+
+    scope :with_actor, ->(actor) { where(actor_id: actor.id).or(where(target_actor_id: actor.id)) }
+
+    def federated_url
+      attributes['federated_url'].presence || Federails::Engine.routes.url_helpers.server_actor_following_url(actor_id: actor_id, id: id)
+    end
+
+    def accept!
+      update! status: :accepted
+      Activity.create! actor: target_actor, action: 'Accept', entity: self
+    end
+
+    class << self
+      def new_from_account(account, actor:)
+        target_actor = Actor.find_or_create_by_account account
+        new actor: actor, target_actor: target_actor
+      end
+    end
+
+    private
+
+    def after_follow
+      target_actor&.entity&.run_callbacks :followed, :after do
+        self
+      end
+    end
+
+    def create_activity
+      Activity.create! actor: actor, action: 'Create', entity: self
+    end
+
+    def destroy_activity
+      Activity.create! actor: actor, action: 'Undo', entity: self
+    end
+  end
+end

data/app/policies/federails/client/activity_policy.rb

@@ -0,0 +1,6 @@
+module Federails
+  module Client
+    class ActivityPolicy < Federails::FederailsPolicy
+    end
+  end
+end

data/app/policies/federails/client/actor_policy.rb

@@ -0,0 +1,15 @@
+module Federails
+  module Client
+    class ActorPolicy < Federails::FederailsPolicy
+      def lookup?
+        true
+      end
+
+      class Scope < Scope
+        def resolve
+          scope.local
+        end
+      end
+    end
+  end
+end

data/app/policies/federails/client/following_policy.rb

@@ -0,0 +1,35 @@
+module Federails
+  module Client
+    class FollowingPolicy < Federails::FederailsPolicy
+      def show?
+        in_following?
+      end
+
+      def destroy?
+        in_following?
+      end
+
+      def accept?
+        in_following? && @record.target_actor_id == @user.actor.id
+      end
+
+      def follow?
+        create?
+      end
+
+      class Scope < Scope
+        def resolve
+          scope.with_actor(@user.actor)
+        end
+      end
+
+      private
+
+      def in_following?
+        return false if @user.blank?
+
+        @record.actor_id == @user.actor.id || @record.target_actor_id == @user.actor.id
+      end
+    end
+  end
+end

data/app/policies/federails/federails_policy.rb

@@ -0,0 +1,59 @@
+module Federails
+  class FederailsPolicy
+    attr_reader :user, :record
+
+    def initialize(user, record)
+      @user = user
+      @record = record
+    end
+
+    def index?
+      true
+    end
+
+    def show?
+      true
+    end
+
+    def create?
+      @user.present?
+    end
+
+    def new?
+      create?
+    end
+
+    def update?
+      owner?
+    end
+
+    def edit?
+      update?
+    end
+
+    def destroy?
+      owner?
+    end
+
+    class Scope
+      attr_reader :user, :scope
+
+      def initialize(user, scope)
+        @user = user
+        @scope = scope
+      end
+
+      def resolve
+        scope.all
+      end
+    end
+
+    private
+
+    def owner?
+      return false unless @user
+
+      @record.actor_id == @user.actor.id
+    end
+  end
+end

data/app/policies/federails/server/activity_policy.rb

@@ -0,0 +1,6 @@
+module Federails
+  module Server
+    class ActivityPolicy < Federails::FederailsPolicy
+    end
+  end
+end

data/app/policies/federails/server/actor_policy.rb

@@ -0,0 +1,23 @@
+module Federails
+  module Server
+    class ActorPolicy < Federails::FederailsPolicy
+      def show?
+        @record.local?
+      end
+
+      def following?
+        true
+      end
+
+      def followers?
+        true
+      end
+
+      class Scope < Scope
+        def resolve
+          scope.local
+        end
+      end
+    end
+  end
+end

data/app/policies/federails/server/following_policy.rb

@@ -0,0 +1,6 @@
+module Federails
+  module Server
+    class FollowingPolicy < Federails::FederailsPolicy
+    end
+  end
+end

data/app/views/federails/client/activities/_activity.html.erb

@@ -0,0 +1,5 @@
+<div>
+  <b><%= activity.actor.name %></b>
+  <code><%= activity.action %></code>
+  <!-- < %= link_to activity.entity_type, activity.entity %>-->
+</div>

data/app/views/federails/client/activities/_activity.json.jbuilder

@@ -0,0 +1 @@
+json.extract! activity, :id, :entity_id, :entity_type, :action, :actor_id, :created_at

data/app/views/federails/client/activities/_index.json.jbuilder

@@ -0,0 +1 @@
+json.array! @activities, partial: 'federails/client/activities/activity', as: :activity

data/app/views/federails/client/activities/feed.html.erb

@@ -0,0 +1,4 @@
+<h1>Your feed !</h1>
+<% @activities.each do |activity| %>
+  <%= render 'activity', activity: activity %>
+<% end %>

data/app/views/federails/client/activities/feed.json.jbuilder

@@ -0,0 +1 @@
+json.partial! 'federails/client/activities/index'

data/app/views/federails/client/activities/index.html.erb

@@ -0,0 +1,5 @@
+<h1>Listing activities</h1>
+
+<%= @activities.each do |activity| %>
+  <%= render 'activity', activity: activity %>
+<% end %>

data/app/views/federails/client/activities/index.json.jbuilder

@@ -0,0 +1 @@
+json.partial! 'federails/client/activities/index'

data/app/views/federails/client/actors/_actor.json.jbuilder

@@ -0,0 +1,14 @@
+json.extract! actor,
+              :id,
+              :name,
+              :federated_url,
+              :username,
+              :inbox_url,
+              :outbox_url,
+              :followers_url,
+              :followings_url,
+              :profile_url,
+              :at_address,
+              :user_id,
+              :created_at,
+              :updated_at

data/app/views/federails/client/actors/_lookup_form.html.erb

@@ -0,0 +1,5 @@
+<%= form_tag federails.lookup_client_actors_url, method: :get do %>
+  <%= label_tag :account %>
+  <%= text_field_tag :account, nil, placeholder: 'user@domain.tld or username', required: true %>
+  <%= submit_tag 'Search' %>
+<% end %>

data/app/views/federails/client/actors/index.html.erb

@@ -0,0 +1,24 @@
+<h1>Listing actors</h1>
+
+<table>
+  <thead>
+  <tr>
+    <th>Name</th>
+    <th>Username</th>
+    <th>Federation address</th>
+    <th>Local?</th>
+    <th></th>
+  </tr>
+  </thead>
+  <tbody>
+  <% @actors.each do |actor| %>
+    <tr>
+      <td><%= actor.name %></td>
+      <td><%= actor.username %></td>
+      <td><%= actor.at_address %></td>
+      <td><%= actor.local? %></td>
+      <td><%= link_to 'Show', federails.client_actor_url(actor) %></td>
+    </tr>
+  <% end %>
+  </tbody>
+</table>

data/app/views/federails/client/actors/index.json.jbuilder

@@ -0,0 +1 @@
+json.array! @actors, partial: 'federails/client/actors/actor', as: :actor