federails 0.6.2 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 28392d4e043a74e77e376374a27a4ee2c86c604b90d0fa0ac7e9ecc337a21630
-  data.tar.gz: cebe905ce0a273bff88ca969a8b0bf72d2f9bc287210dcaf7fd48042a182edce
+  metadata.gz: 07b0025f15cc58379219f20956c53c0c3e6810e68ac60367b9728c9eff03220b
+  data.tar.gz: 22957563450ab52509a350e6e50f397cb564396c0927c510439ea1ad041106d9
 SHA512:
-  metadata.gz: 660950645cf4a9af0d3d8dd34337a3857d038f487cc22a3199d78d9cdcdfc17cad165955aba8163c1e2c084be39fdbd639c571b7a9bd88658fed96f2d73b1615
-  data.tar.gz: cfcf8fc68460ef4eb7e66e9d4a459cf29863f2330f903d5967ef5d4bb43f3817963e355eb3690d84798674664dce0267ccb0ab05772274e2cb06a97aa152bf2b
+  metadata.gz: 72e09779f3cdd23101c29e659f568f5dfddb5c85453c3853d49d1d7408b8017ea6c836b1b06afd6e3d62a6a476b8ce6746ec78b10e7f0d06ab32e825b947c258
+  data.tar.gz: 2b6bd12fb24cb50925e637c10f5f16453afa799a438695e36a77c3478c7394d3b3204ca8f6cbcddad49dfa1a031dd5a3ffaefb42c100b946f5c6ca8ae4550128

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/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

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/models/concerns/federails/actor_entity.rb

@@ -158,5 +158,9 @@ module Federails
     def tombstone_federails_actor!
       federails_actor.tombstone! if federails_actor.present?
     end
+
+    def untombstone_federails_actor!
+      federails_actor.untombstone! if federails_actor.present?
+    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/actor.rb

@@ -33,7 +33,9 @@ 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
 
     scope :local, -> { where(local: true) }
@@ -42,6 +44,7 @@ module Federails
     scope :not_tombstoned, -> { where(tombstoned_at: nil) }
 
     on_federails_delete_requested -> { tombstone! }
+    on_federails_undelete_requested -> { untombstone! }
 
     def distant?
       !local?
@@ -96,8 +99,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,6 +111,9 @@ 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
@@ -115,12 +121,37 @@ module Federails
       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.count == 1
+
+      false
+    end
+
     def entity_configuration
       raise("Entity not configured for #{entity_type}. Did you use \"acts_as_federails_actor\"?") unless Federails.actor_entity? entity_type
 
       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 +160,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/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 %>

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

@@ -1,7 +1,7 @@
 <div>
   <b><%= link_to following.actor.name, federails.client_actor_url(following.actor) %></b>
   (<%= following.actor.at_address %>) (<%= following.status %>)
-  <% if following.pending? && following.target_actor == current_user.federails_actor %>
+  <% if following.pending? && following.target_actor == current_user&.federails_actor %>
     <%= button_to 'Accept', federails.accept_client_following_path(following), method: :put %>
   <% end %>
 </div>

data/app/views/federails/server/nodeinfo/index.nodeinfo.jbuilder

@@ -1,6 +1,6 @@
 json.links [
   {
-    rel:  'https://nodeinfo.diaspora.software/ns/schema/2.0',
+    rel:  'http://nodeinfo.diaspora.software/ns/schema/2.0',
     href: show_node_info_url,
   },
 ]

data/lib/federails/configuration.rb

@@ -58,6 +58,13 @@ module Federails
     # @!method self.remote_follow_url_method=(value)
     #
     # Sets the route method for remote-following requests
+    #
+    # The route should lead to a page displaying the remote actor and a button to follow it.
+    # Remote actor is specified in the `uri` query parameter.
+    #
+    # Its value defaults to a route of the Federails client, so your application will break
+    # if you don't use the client routes and don't override this value.
+    #
     # @param value [String] Route method name as used in links
     # @example
     #   remote_follow_url_method 'main_app.my_custom_route_helper'

data/lib/federails/maintenance/actors_updater.rb

@@ -54,12 +54,11 @@ module Federails
         def update(actor)
           return :ignored_local if actor.local?
 
-          response = Fediverse::Webfinger.fetch_actor_url(actor.federated_url)
-          new_attributes = response.attributes.except 'id', 'uuid', 'created_at', 'updated_at', 'local', 'entity_id', 'entity_type'
-
-          actor.update(new_attributes) ? :updated : :failed
+          actor.sync! ? :updated : :failed
         rescue ActiveRecord::RecordNotFound
           :not_found
+        rescue StandardError
+          :failed
         end
       end
     end

data/lib/federails/utils/actor.rb

@@ -27,13 +27,21 @@ module Federails
           actor
         end
 
+        def untombstone!(actor)
+          if actor.local?
+            untombstone_local_actor actor
+          else
+            untombstone_distant_actor actor
+          end
+        end
+
         private
 
         def tombstone_local_actor(actor)
           Federails::Actor.transaction do
             hash = {
               tombstoned_at: Time.current,
-              entity:        nil,
+              entity:        actor.entity || nil,
             }
             # Hardcode attributes depending on the actor's entity
             COMPUTED_ATTRIBUTES.each { |attribute| hash[attribute] = actor.send(attribute) }
@@ -44,9 +52,33 @@ module Federails
           end
         end
 
+        def untombstone_local_actor(actor)
+          return unless actor.tombstoned?
+          raise 'Cannot restore a local actor without an entity' if actor.entity.blank?
+
+          Federails::Actor.transaction do
+            # Reset hardcoded attributes depending on the actor's entity
+            hash = { tombstoned_at: nil }
+            COMPUTED_ATTRIBUTES.each { |attribute| hash[attribute] = nil }
+
+            actor.update! hash
+
+            delete_activity = Activity.find_by actor: actor, action: 'Delete', entity: actor
+            return unless delete_activity
+
+            Activity.create! actor: actor, action: 'Undo', entity: delete_activity
+          end
+        end
+
         def tombstone_distant_actor(actor)
           actor.update! tombstoned_at: Time.current
         end
+
+        def untombstone_distant_actor(actor)
+          actor.tombstoned_at = nil
+          actor.sync!
+          actor.save
+        end
       end
     end
   end

data/lib/federails/utils/json_request.rb

@@ -0,0 +1,41 @@
+require 'faraday'
+require 'faraday/follow_redirects'
+
+module Federails
+  module Utils
+    # Simple wrapper to make requests expecting JSON
+    module JsonRequest
+      class UnhandledResponseStatus < StandardError; end
+
+      BASE_HEADERS = {
+        'Content-Type' => 'application/json',
+        'Accept'       => 'application/json',
+      }.freeze
+
+      # Makes a GET request and returns a +Hash+ from the parsed body
+      #
+      # @param url [String] Target URL
+      # @param params [Hash] Querystring parameters
+      # @param headers [Hash] Additional headers
+      # @param follow_redirects [Boolean] Whether to follow redirections
+      # @param expected_status [Integer] Expected response status. Will raise a +UnhandledResponseStatus+ when status is different
+      #
+      # @return The parsed JSON object
+      #
+      # @raise [UnhandledResponseStatus] when response status is not the expected_status
+      def self.get_json(url, params: {}, headers: {}, follow_redirects: false, expected_status: 200)
+        headers = BASE_HEADERS.merge headers
+
+        connection = Faraday.new url: url, params: params, headers: headers do |faraday|
+          faraday.response :follow_redirects if follow_redirects
+          faraday.adapter Faraday.default_adapter
+        end
+
+        response = connection.get
+        raise UnhandledResponseStatus, "Unhandled status code #{response.status} for GET #{url}" if expected_status && response.status != expected_status
+
+        JSON.parse(response.body)
+      end
+    end
+  end
+end

data/lib/federails/utils/object.rb

@@ -121,7 +121,7 @@ module Federails
           entity = handler[:class].new_from_activitypub_object(hash)
           return unless entity
 
-          entity.federails_actor = Federails::Actor.find_or_create_by_object hash['attributedTo'] if entity && !entity.federails_actor
+          entity.federails_actor = Federails::Actor.find_by_federation_url hash['attributedTo'] if entity && !entity.federails_actor
 
           entity
         end

data/lib/federails/version.rb

@@ -1,3 +1,3 @@
 module Federails
-  VERSION = '0.6.2'.freeze
+  VERSION = '0.7.0'.freeze
 end

data/lib/federails.rb

@@ -1,7 +1,12 @@
+require 'jbuilder'
+require 'kaminari'
+require 'pundit'
+
 require 'federails/version'
 require 'federails/engine'
 require 'federails/configuration'
 require 'federails/utils/object'
+require 'federails/utils/json_request'
 
 # rubocop:disable Style/ClassVars
 

data/lib/fediverse/inbox.rb

@@ -90,11 +90,21 @@ module Fediverse
 
         object.run_callbacks :on_federails_delete_requested
       end
+
+      def handle_undelete_request(activity)
+        # Get to original object
+        delete_activity = Request.dereference(activity['object'])
+        object = Federails::Utils::Object.find_distant_object_in_all(delete_activity['object'])
+        return if object.blank?
+
+        object.run_callbacks :on_federails_undelete_requested
+      end
     end
 
     register_handler 'Follow', '*', self, :handle_create_follow_request
     register_handler 'Accept', 'Follow', self, :handle_accept_follow_request
     register_handler 'Undo', 'Follow', self, :handle_undo_follow_request
     register_handler 'Delete', '*', self, :handle_delete_request
+    register_handler 'Undo', 'Delete', self, :handle_undelete_request
   end
 end

data/lib/fediverse/node_info.rb

@@ -0,0 +1,38 @@
+module Fediverse
+  class NodeInfo
+    class NotFoundError < StandardError; end
+    class NoActivityPubError < StandardError; end
+
+    class << self
+      def fetch(domain)
+        url = nodeinfo_url(domain)
+
+        hash = Federails::Utils::JsonRequest.get_json url
+        raise NoActivityPubError, "#{domain} does not handle activitypub protocol" unless hash['protocols'].include? 'activitypub'
+
+        {
+          domain:           domain,
+          nodeinfo_url:     url,
+          software_version: hash.dig('software', 'version'),
+          software_name:    hash.dig('software', 'name'),
+          protocols:        hash['protocols'],
+          services:         hash['services'],
+        }
+      end
+
+      private
+
+      def base_url(domain)
+        scheme = Federails::Configuration.force_ssl ? 'https' : 'http'
+        @base_url = "#{scheme}://#{domain}"
+      end
+
+      def nodeinfo_url(domain)
+        response = Federails::Utils::JsonRequest.get_json "#{base_url(domain)}/.well-known/nodeinfo", follow_redirects: true
+        entry = response['links']&.find { |link| link['rel'] == 'http://nodeinfo.diaspora.software/ns/schema/2.0' }
+
+        entry['href']
+      end
+    end
+  end
+end

data/lib/fediverse/request.rb

@@ -2,27 +2,7 @@ require 'json/ld'
 
 module Fediverse
   class Request
-    BASE_HEADERS = {
-      'Content-Type' => 'application/json',
-      'Accept'       => 'application/json',
-    }.freeze
-
-    def initialize(id)
-      @id = id
-    end
-
-    # FIXME: Replace by `Webfinger.get_json` (move other method here as class method)
-    def get
-      Rails.logger.debug { "GET #{@id}" }
-      @response = Faraday.get(@id, nil, BASE_HEADERS)
-      response_to_json
-    end
-
     class << self
-      def get(id)
-        new(id).get
-      end
-
       # Dereferences a value
       #
       # @param value [String, Hash]
@@ -34,18 +14,16 @@ module Fediverse
 
         raise "Unhandled object type #{value.class}"
       end
-    end
 
-    private
+      private
 
-    def response_to_json
-      begin
-        body = JSON.parse @response.body
+      def get(id)
+        json = Federails::Utils::JsonRequest.get_json(id)
+
+        JSON::LD::API.compact json, json['@context']
       rescue JSON::ParserError
-        return
+        nil
       end
-
-      JSON::LD::API.compact body, body['@context']
     end
   end
 end

data/lib/fediverse/webfinger.rb

@@ -1,7 +1,5 @@
-require 'faraday'
-require 'faraday/follow_redirects'
-
 require 'federails/utils/host'
+require 'federails/utils/json_request'
 
 module Fediverse
   # Methods related to Webfinger: find accounts, fetch actors,...
@@ -122,42 +120,21 @@ module Fediverse
       # Makes a simple GET request and returns a +Hash+ from the parsed body
       # @return [Hash]
       # @raise [ActiveRecord::RecordNotFound] when the response is invalid
-      def get_json(url, payload = {})
-        response = get(url, payload: payload, headers: { accept: 'application/json' })
+      def get_json(url, params = {})
+        Federails::Utils::JsonRequest.get_json(url, params: params, follow_redirects: true, headers: { accept: 'application/json' })
+      rescue Federails::Utils::JsonRequest::UnhandledResponseStatus => e
+        Rails.logger.debug { e.message }
 
-        if response.status != 200
-          Rails.logger.debug { "Unhandled status code #{response.status} for GET #{url}" }
-          raise ActiveRecord::RecordNotFound
-        end
+        raise ActiveRecord::RecordNotFound
+      rescue Faraday::ConnectionFailed
+        Rails.logger.debug { "Failed to reach server for GET #{url}" }
 
-        JSON.parse(response.body)
+        raise ActiveRecord::RecordNotFound
       rescue JSON::ParserError
-        Rails.logger.debug { "Invalid JSON response GET #{url}" }
+        Rails.logger.debug { "Invalid JSON response for GET #{url}" }
 
         raise ActiveRecord::RecordNotFound
       end
-
-      # Only perform a GET request and throws an ActiveRecord::RecordNotFound on error.
-      #
-      # That's "ok-ish"; when an actor is unavailable, whatever the reason is, it's not found...
-      #
-      # @return [Faraday::Response]
-      # @raise [ActiveRecord::RecordNotFound] when the response is invalid
-      def get(url, payload: {}, headers: {})
-        connection = Faraday.new url: url, params: payload, headers: headers do |faraday|
-          faraday.response :follow_redirects # use Faraday::FollowRedirects::Middleware
-          faraday.adapter Faraday.default_adapter
-        end
-
-        begin
-          response = connection.get
-        rescue Faraday::ConnectionFailed
-          Rails.logger.debug { "Failed to reach server for GET #{url}" }
-          raise ActiveRecord::RecordNotFound
-        end
-
-        response
-      end
     end
   end
 end

data/lib/generators/federails/copy_client_policies/USAGE

@@ -0,0 +1,8 @@
+Description:
+    Copies the Pundit client policies to be overridden in main application.
+
+Example:
+    bin/rails generate copy_client_policies
+
+    This will create:
+        app/policies/federails/client/*

data/lib/generators/federails/copy_client_policies/copy_client_policies_generator.rb

@@ -0,0 +1,9 @@
+module Federails
+  class CopyClientPoliciesGenerator < Rails::Generators::Base
+    source_root File.expand_path('../../../../app/policies/federails', __dir__)
+
+    def copy_policies
+      directory 'client', Rails.root.join('app', 'policies', 'federails', 'client')
+    end
+  end
+end

data/lib/generators/federails/copy_factories/USAGE

@@ -0,0 +1,8 @@
+Description:
+    Copies FactoryBot factories in the "spec" directory
+
+Example:
+    bin/rails generate copy_factories
+
+    This will create:
+        spec/factories/*

data/lib/generators/federails/copy_factories/copy_factories_generator.rb

@@ -0,0 +1,21 @@
+module Federails
+  class CopyFactoriesGenerator < Rails::Generators::Base
+    SOURCE_DIRECTORY = File.expand_path('../../../../spec/factories/federails', __dir__)
+
+    source_root SOURCE_DIRECTORY
+
+    def copy_factories
+      dest = Rails.root.join('spec', 'factories')
+
+      Dir.entries(SOURCE_DIRECTORY)
+         .each do |node|
+        source_path = File.join(SOURCE_DIRECTORY, node)
+        next unless File.file?(source_path) && node.match?(/\.rb\Z/)
+
+        file_path = File.join(dest, "federails_#{node}")
+        copy_file node, file_path
+        gsub_file file_path, /(FactoryBot.define do\n\s+factory) :(\w+),/, '\1 :federails_\2,'
+      end
+    end
+  end
+end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: federails
 version: !ruby/object:Gem::Version
-  version: 0.6.2
+  version: 0.7.0
 platform: ruby
 authors:
 - Manuel Tancoigne
 bindir: bin
 cert_chain: []
-date: 2025-04-18 00:00:00.000000000 Z
+date: 2025-05-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
@@ -37,6 +37,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: jbuilder
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.7'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.7'
 - !ruby/object:Gem::Dependency
   name: json-ld
   requirement: !ruby/object:Gem::Requirement
@@ -209,16 +223,22 @@ files:
 - lib/federails/maintenance/actors_updater.rb
 - lib/federails/utils/actor.rb
 - lib/federails/utils/host.rb
+- lib/federails/utils/json_request.rb
 - lib/federails/utils/object.rb
 - lib/federails/version.rb
 - lib/fediverse.rb
 - lib/fediverse/inbox.rb
+- lib/fediverse/node_info.rb
 - lib/fediverse/notifier.rb
 - lib/fediverse/request.rb
 - lib/fediverse/signature.rb
 - lib/fediverse/webfinger.rb
+- lib/generators/federails/copy_client_policies/USAGE
+- lib/generators/federails/copy_client_policies/copy_client_policies_generator.rb
 - lib/generators/federails/copy_client_views/USAGE
 - lib/generators/federails/copy_client_views/copy_client_views_generator.rb
+- lib/generators/federails/copy_factories/USAGE
+- lib/generators/federails/copy_factories/copy_factories_generator.rb
 - lib/generators/federails/install/USAGE
 - lib/generators/federails/install/install_generator.rb
 - lib/generators/federails/install/templates/federails.rb