fedipub 0.0.1 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 26b8e43a825419cc29580d3ac1aa08ed0963d9a6a2037e4df12367ecd8519d1f
-  data.tar.gz: 2a8d9d19556046c52b6a9db3aba4682886449af998b3b15ab25ffeecbd712f96
+  metadata.gz: e48fe0306a23dd822ac8e755412635303612686408512d9cd36139050fc961a7
+  data.tar.gz: ca741f66e2d65b4501b9ae80465fde3500f81d65f55b56b0eef1d0a96bf2b97c
 SHA512:
-  metadata.gz: 41a29d437859cc4d3e19aab1065e11ba3be55cfd27164b256d813fa83ea2931e7ca381a88816b870b0dde73d74f4fb00a86cc89a465879d7521e2fc229bc7708
-  data.tar.gz: 5f086dff6232c1d0a156e06a5757aebe7ec172079bb4e01d0989026d0cb3d1e3c0c19266528aa3fbb5a557dc1c10effa269088f2d1625d1ad1b2e38b6effda42
+  metadata.gz: e96c6dcb707777a477078d15b750e2257dafecdd7c489a21f2c8beea9c965be237da1ed414ac27327e684874d840d11274336106defb1d1fe43df242b6b274e8
+  data.tar.gz: da1eca4e3c5d882a0dabec9668d521f1f9a707a6dfcbfe36d4ed6d42ffa761d0c7049ffc67d3d1666cae535d85af6ff80cdb11582ff4e6d068365e0949ed737c

data/README.md

@@ -1,3 +1,71 @@
-Placeholder repository to publish a v0.0.1 on rubygems until we migrated the real code.
+# Fedipub
 
-For now, check https://gitlab.com/fedipub/fedipub.
+Fedipub is an engine that brings ActivityPub to Ruby on Rails application.
+
+> [!note]
+> This project was know as _Federails_ (and the `federails` gem and extensions) and has been
+> renamed recently to Fedipub.
+
+## Community
+
+You can join the [matrix chat room](https://matrix.to/#/#fedipub:matrix.org) to chat with humans.
+
+Open issues or feature requests on the [issue tracker](https://gitlab.com/fedipub/fedipub/-/issues)
+
+## Features
+
+This engine is meant to be used in Rails applications to add the ability to act as an ActivityPub server.
+
+As the project is in an early stage of development we're unable to provide a clean list of what works and what is missing.
+
+The general direction is to be able to:
+
+- publish and subscribe to any type of content
+- have a discovery endpoint (`webfinger`)
+- have a following/followers system
+- implement all the parts of the (RFC) labelled with **MUST** and **MUST NOT**
+- 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](https://endoflife.date/ruby) and [Rails](https://endoflife.date/rails):
+
+- Ruby versions 3.3, 3.4 and 4.0
+- Rails 7.2 to 8.1.
+
+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](CONTRIBUTING.md)
+
+## Extensions
+
+Extensions add extra features to Fedipub:
+
+- [Fedipub Moderation](https://github.com/fedipub/fedipub-moderation/)
+  > A gem that provides trust & safety for Fedipub
+
+## 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)
+- [pessi-v](https://github.com/pessi-v)
+
+### Indirect contributions
+
+- Gitlab runners are graciously provided by [Coopaname](https://coopaname.coop), a French cooperative.

data/Rakefile

@@ -1,12 +1,8 @@
-# frozen_string_literal: true
+require 'bundler/setup'
 
-require "bundler/gem_tasks"
-require "rspec/core/rake_task"
+APP_RAKEFILE = File.expand_path('spec/dummy/Rakefile', __dir__)
+load 'rails/tasks/engine.rake'
 
-RSpec::Core::RakeTask.new(:spec)
+load 'rails/tasks/statistics.rake'
 
-require "rubocop/rake_task"
-
-RuboCop::RakeTask.new
-
-task default: %i[spec rubocop]
+require 'bundler/gem_tasks'

data/app/assets/config/fedipub_manifest.js

@@ -0,0 +1 @@
+//= link_directory ../stylesheets/fedipub .css

data/app/assets/stylesheets/fedipub/application.css

@@ -0,0 +1,15 @@
+/*
+ * This is a manifest file that'll be compiled into application.css, which will include all the files
+ * listed below.
+ *
+ * Any CSS and SCSS file within this directory, lib/assets/stylesheets, vendor/assets/stylesheets,
+ * or any plugin's vendor/assets/stylesheets directory can be referenced here using a relative path.
+ *
+ * You're free to add application-wide styles to this file and they'll appear at the bottom of the
+ * compiled file so the styles you add here take precedence over styles defined in any other CSS/SCSS
+ * files in this directory. Styles in this file should be added after the last require_* statement.
+ * It is generally better to create a new file per style scope.
+ *
+ *= require_tree .
+ *= require_self
+ */

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

@@ -0,0 +1,19 @@
+module Fedipub
+  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 'fedipub/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 'fedipub/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/fedipub/client/activities_controller.rb

@@ -0,0 +1,27 @@
+module Fedipub
+  module Client
+    class ActivitiesController < Fedipub::ClientController
+      before_action :authenticate_user!, only: [:feed]
+      before_action :authorize_action!
+
+      # GET /app/activities
+      # GET /app/activities.json
+      def index
+        @activities = policy_scope(Fedipub::Activity, policy_scope_class: Fedipub::Client::ActivityPolicy::Scope).all
+        @activities = @activities.where actor: Actor.find_param(params[:actor_id]) if params[:actor_id]
+      end
+
+      # GET /app/feed
+      # GET /app/feed.json
+      def feed
+        @activities = Activity.feed_for(current_user.fedipub_actor)
+      end
+
+      private
+
+      def authorize_action!
+        authorize(Fedipub::Activity, policy_class: Fedipub::Client::ActivityPolicy)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,54 @@
+module Fedipub
+  module Client
+    class ActorsController < Fedipub::ClientController
+      before_action :set_actor, only: [:show]
+
+      # GET /app/actors
+      # GET /app/actors.json
+      def index
+        authorize Fedipub::Actor, policy_class: Fedipub::Client::ActorPolicy
+
+        @actors = policy_scope(Fedipub::Actor, policy_scope_class: Fedipub::Client::ActorPolicy::Scope).all
+        @actors = @actors.local if params[:local_only]
+      end
+
+      # GET /app/actors/1
+      # GET /app/actors/1.json
+      def show
+        render_show
+      end
+
+      # GET /app/actors/lookup
+      # GET /app/actors/lookup.json
+      def lookup
+        @actor = Fedipub::Actor.find_by_account account_param
+        authorize @actor, policy_class: Fedipub::Client::ActorPolicy
+        render_show
+      end
+
+      private
+
+      # Use callbacks to share common setup or constraints between actions.
+      def set_actor
+        @actor = Fedipub::Actor.find_param(params[:id])
+        authorize @actor, policy_class: Fedipub::Client::ActorPolicy
+      end
+
+      def account_param
+        params.require('account').strip
+      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/fedipub/client/followings_controller.rb

@@ -0,0 +1,103 @@
+module Fedipub
+  module Client
+    class FollowingsController < Fedipub::ClientController
+      before_action :authenticate_user!
+      before_action :skip_authorization, only: [:new, :create]
+      before_action :set_following, only: [:accept, :destroy]
+
+      # GET /app/followings/new?uri={uri}
+      def new
+        # Find actor (and fetch if necessary)
+        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 fedipub.client_actor_url(actor)
+      end
+
+      # PUT /app/followings/:id/accept
+      # PUT /app/followings/:id/accept.json
+      def accept
+        respond_to do |format|
+          url = fedipub.client_actor_url @following.actor
+          if @following.accept!
+            format.html { redirect_to url, notice: I18n.t('controller.followings.accept.success') }
+            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: Fedipub::Utils::ResponseCodes::UNPROCESSABLE_CONTENT }
+          end
+        end
+      end
+
+      # POST /app/followings
+      # POST /app/followings.json
+      def create
+        @following = Following.new(following_params)
+        @following.actor = current_user.fedipub_actor
+        authorize @following, policy_class: Fedipub::Client::FollowingPolicy
+
+        save_and_render
+      end
+
+      # POST /app/followings/follow
+      # POST /app/followings/follow.json
+      def follow
+        authorize Fedipub::Following, policy_class: Fedipub::Client::FollowingPolicy
+
+        begin
+          @following = Following.new_from_account following_account_params, actor: current_user.fedipub_actor
+        rescue ::ActiveRecord::RecordNotFound
+          # Renders a 422 instead of a 404
+          respond_to do |format|
+            format.html { redirect_to fedipub.client_actors_url, alert: I18n.t('controller.followings.follow.error') }
+            format.json { render json: { target_actor: ['does not exist'] }, status: Fedipub::Utils::ResponseCodes::UNPROCESSABLE_CONTENT }
+          end
+
+          return
+        end
+
+        save_and_render
+      end
+
+      # DELETE /app/followings/1
+      # DELETE /app/followings/1.json
+      def destroy
+        @following.destroy
+        respond_to do |format|
+          format.html { redirect_to fedipub.client_actor_url(@following.actor), notice: I18n.t('controller.followings.destroy.success') }
+          format.json { head :no_content }
+        end
+      end
+
+      private
+
+      # Use callbacks to share common setup or constraints between actions.
+      def set_following
+        @following = Following.find_param(params[:id])
+        authorize @following, policy_class: Fedipub::Client::FollowingPolicy
+      end
+
+      # Only allow a list of trusted parameters through.
+      def following_params
+        params.require(:following).permit(:target_actor_id)
+      end
+
+      def following_account_params
+        params.require(:account)
+      end
+
+      def save_and_render # rubocop:disable Metrics/AbcSize
+        url = fedipub.client_actor_url current_user.fedipub_actor
+
+        respond_to do |format|
+          if @following.save
+            format.html { redirect_to url, notice: I18n.t('controller.followings.save_and_render.success') }
+            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: Fedipub::Utils::ResponseCodes::UNPROCESSABLE_CONTENT }
+          end
+        end
+      end
+    end
+  end
+end

data/app/controllers/fedipub/client_controller.rb

@@ -0,0 +1,9 @@
+module Fedipub
+  class ClientController < Fedipub.configuration.base_client_controller.constantize
+    include Pundit::Authorization
+
+    after_action :verify_authorized
+
+    layout Fedipub.configuration.app_layout if Fedipub.configuration.app_layout
+  end
+end

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

@@ -0,0 +1,78 @@
+require 'fediverse/inbox'
+
+module Fedipub
+  module Server
+    class ActivitiesController < Fedipub::ServerController
+      include Fedipub::Server::RenderCollections
+
+      before_action :set_activity, only: [:show]
+
+      # GET /federation/activities
+      # GET /federation/actors/1/outbox.json
+      def outbox
+        authorize Fedipub::Activity, policy_class: Fedipub::Server::ActivityPolicy
+
+        actor            = Actor.find_param(params[:actor_id])
+        activities       = policy_scope(Fedipub::Activity, policy_scope_class: Fedipub::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: 'fedipub/server/activities/activity', as: :activity, context: false
+        end
+      end
+
+      # GET /federation/actors/1/activities/1.json
+      def show; end
+
+      # POST /federation/actors/1/inbox
+      def create
+        skip_authorization
+
+        payload = payload_from_params
+        return head Fedipub::Utils::ResponseCodes::UNPROCESSABLE_CONTENT unless payload
+
+        if Fediverse::Inbox.dispatch_request(payload)
+          head :created
+        else
+          head Fedipub::Utils::ResponseCodes::UNPROCESSABLE_CONTENT
+        end
+      end
+
+      private
+
+      # Use callbacks to share common setup or constraints between actions.
+      def set_activity
+        @activity = Actor.find_param(params[:actor_id]).activities.find_param(params[:id])
+        authorize @activity, policy_class: Fedipub::Server::ActivityPolicy
+      end
+
+      # Only allow a list of trusted parameters through.
+      def activity_params
+        params.fetch(:activity, {})
+      end
+
+      def payload_from_params
+        payload_string = request.body.read
+        request.body.rewind if request.body.respond_to? :rewind
+
+        begin
+          payload = JSON.parse(payload_string)
+        rescue JSON::ParserError
+          return
+        end
+
+        hash = JSON::LD::API.compact payload, payload['@context']
+        validate_payload hash
+      end
+
+      def validate_payload(hash)
+        return unless hash['@context'] && hash['id'] && hash['type'] && hash['actor'] && hash['object']
+
+        hash
+      end
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+module Fedipub
+  module Server
+    class ActorsController < Fedipub::ServerController
+      include Fedipub::Server::RenderCollections
+
+      before_action :set_actor, only: [:show, :followers, :following]
+
+      # GET /federation/actors/1
+      # GET /federation/actors/1.json
+      def show
+        status = @actor.tombstoned? ? :gone : :ok
+        render :show, status: status
+      end
+
+      # GET /federation/actors/:id/followers
+      # GET /federation/actors/:id/followers.json
+      def followers
+        @actors = @actor.followers.order(created_at: :desc)
+        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)
+        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
+
+      # Use callbacks to share common setup or constraints between actions.
+      def set_actor
+        @actor = Actor.find_param(params[:id])
+        authorize @actor, policy_class: Fedipub::Server::ActorPolicy
+      end
+    end
+  end
+end

data/app/controllers/fedipub/server/followings_controller.rb

@@ -0,0 +1,19 @@
+module Fedipub
+  module Server
+    class FollowingsController < Fedipub::ServerController
+      before_action :set_following, only: [:show]
+
+      # GET /federation/actors/1/followings/1.json
+      def show; end
+
+      private
+
+      # Use callbacks to share common setup or constraints between actions.
+      def set_following
+        actor = Actor.find_param(params[:actor_id])
+        @following = Following.find_by!(actor: actor, uuid: params[:id])
+        authorize @following, policy_class: Fedipub::Server::FollowingPolicy
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+module Fedipub
+  module Server
+    class NodeinfoController < Fedipub::ServerController
+      def index
+        skip_authorization
+
+        render formats: [:nodeinfo]
+      end
+
+      def show # rubocop:todo Metrics/AbcSize
+        skip_authorization
+
+        @total = @active_halfyear = @active_month = 0
+        @has_user_counts = false
+        Fedipub::Configuration.actor_types.each_value do |config|
+          next unless (method = config[:user_count_method]&.to_sym)
+
+          @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)
+        end
+        render formats: [:nodeinfo]
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+module Fedipub
+  module Server
+    # Controller to render ActivityPub representation of entities configured with Fedipub::DataEntity
+    class PublishedController < Fedipub::ServerController
+      def show
+        @publishable = type_scope.find_untombstoned_by!(url_param => params[:id])
+        authorize @publishable, policy_class: Fedipub::Server::PublishablePolicy
+      end
+
+      private
+
+      def publishable_config
+        return @publishable_config if instance_variable_defined? :@publishable_config
+
+        _, @publishable_config = Fedipub.configuration.data_types.find { |_, v| v[:route_path_segment].to_s == params[:publishable_type] }
+        raise ActiveRecord::RecordNotFound, "Invalid #{params[:publishable_type]} type" unless @publishable_config
+
+        @publishable_config
+      end
+
+      def url_param
+        publishable_config[:url_param]
+      end
+
+      def type_scope
+        publishable_config[:class].all
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+require 'fediverse/webfinger'
+
+module Fedipub
+  module Server
+    class WebFingerController < Fedipub::ServerController
+      def find
+        skip_authorization
+
+        resource = params.require(:resource)
+        case resource
+        when %r{^https?://.+}
+          @user = Fedipub::Actor.find_by_federation_url!(resource).entity # rubocop:disable Rails/DynamicFindBy
+        when /^acct:.+/
+          actor = Fedipub::Actor.find_local_by_username(username)
+          raise Fedipub::Actor::TombstonedError if actor&.tombstoned?
+
+          @user = actor&.entity
+        end
+        raise ActiveRecord::RecordNotFound if @user.nil?
+
+        render formats: [:jrd]
+      end
+
+      def host_meta
+        skip_authorization
+
+        render formats: [:xrd]
+      end
+
+      # TODO: complete missing endpoints
+
+      private
+
+      def username
+        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)
+
+        @username = account[:username]
+      end
+    end
+  end
+end

data/app/controllers/fedipub/server_controller.rb

@@ -0,0 +1,37 @@
+module Fedipub
+  class ServerController < ::ActionController::Base # rubocop:disable Rails/ApplicationController
+    include Pundit::Authorization
+
+    after_action :verify_authorized
+
+    protect_from_forgery with: :null_session
+    helper Fedipub::ServerHelper
+
+    rescue_from ActiveRecord::RecordNotFound, with: :error_not_found
+    rescue_from Fedipub::Actor::TombstonedError,
+                Fedipub::DataEntity::TombstonedError,
+                with: :error_gone
+
+    private
+
+    def error_fallback(exception, fallback_message, status)
+      message = exception&.message || fallback_message
+      respond_to do |format|
+        format.jrd { head status }
+        format.xrd { head status }
+        format.activitypub { head status }
+        format.nodeinfo { head status }
+        format.json { render json: { error: message }, status: status }
+        format.html { raise exception }
+      end
+    end
+
+    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/helpers/fedipub/server_helper.rb

@@ -0,0 +1,18 @@
+require 'fedipub/utils/context'
+
+module Fedipub
+  module ServerHelper
+    def remote_follow_url
+      method_name = Fedipub.configuration.remote_follow_url_method.to_s
+      if method_name.starts_with? 'fedipub.'
+        send(method_name.gsub('fedipub.', ''))
+      else
+        Rails.application.routes.url_helpers.send(method_name)
+      end
+    end
+
+    def set_json_ld_context(json, additional: nil)
+      json.set! '@context', Fedipub::Utils::Context.generate(additional: additional)
+    end
+  end
+end

data/app/jobs/fedipub/application_job.rb

@@ -0,0 +1,10 @@
+module Fedipub
+  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
+    end
+  end
+end

data/app/jobs/fedipub/fetch_nodeinfo_job.rb

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