jekyll-activity-pub 0.1.0rc0

data/lib/jekyll/activity_pub/helper.rb

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+require 'jekyll/hooks'
+
+module Jekyll
+  module ActivityPub
+    # Container for common tools
+    module Helper
+      include Jekyll::Filters::URLFilters
+
+      # Some filters needs a Liquid-like context
+      StubContext = Struct.new(:registers, keyword_init: true)
+
+      # Renders the data hash as a stringified JSON
+      #
+      # @return [String]
+      def content
+        data.to_json
+      end
+
+      # JSONify this object
+      def to_json(*args)
+        data.to_json(*args)
+      end
+
+      # There's no excerpt to be generated
+      #
+      # @return [Boolean]
+      def generate_excerpt?
+        false
+      end
+
+      # Trigger hooks
+      #
+      # @param :hook_name [Symbol]
+      # @param :args [any]
+      # @return [nil]
+      def trigger_hooks(hook_name, *args)
+        Jekyll::Hooks.trigger hook_owner, hook_name.to_sym, self, *args
+      end
+
+      # Simpler version of ActiveSupport::Inflector#underscore
+      #
+      # https://stackoverflow.com/a/1510078
+      #
+      # @see Jekyll::Convertible
+      # @return [Symbol]
+      def hook_owner
+        @hook_owner ||= self.class.name.split('::').last.gsub(/(.)([A-Z])/, '\1_\2').downcase.to_sym
+      end
+
+      alias type hook_owner
+
+      private
+
+      # Is Liquid on strict mode?
+      #
+      # @return [Boolean]
+      def strict?
+        site.config.dig('liquid', 'strict_variables')
+      end
+
+      # Returns site name, for use as a username.  "site" by default.
+      #
+      # @return [String]
+      def username
+        @username ||= site.config.dig('activity_pub', 'username')
+        @username ||= hostname&.split('.', 2)&.first
+        @username ||= 'site'
+      end
+
+      # Return hostname
+      #
+      # @return [String]
+      def hostname
+        return @hostname if defined? @hostname
+
+        @hostname   = site.config.dig('activity_pub', 'hostname')
+        @hostname ||= site.config['hostname']
+        @hostname ||= Addressable::URI.parse(site.config['url']).hostname if site.config['url']
+        @hostname ||= File.read(cname_file).strip if cname_file?
+
+        if @hostname.nil? || @hostname.empty?
+          raise ArgumentError, 'Site must have a hostname' if strict?
+
+          Jekyll.logger.warn 'ActivityPub:', 'Site must have a hostname'
+
+        end
+
+        @hostname
+      end
+
+      # Site uses CNAME file
+      #
+      # @return [String]
+      def cname_file
+        @cname_file ||= site.in_source_dir('CNAME')
+      end
+
+      # @return [Boolean]
+      def cname_file?
+        File.exist?(cname_file)
+      end
+
+      # Detects locale
+      #
+      # @return [String]
+      def locale
+        return @locale if defined? @locale
+
+        @locale   = site.config['locale']
+        @locale ||= ENV['LANG']&.split('.', 2)&.first
+
+        @locale = @locale&.tr('_', '-')
+      end
+
+      # Finds the value of a text field amongst options
+      #
+      # @params :hash [Hash] The haystack
+      # @param :args [String,Array] A combination of paths to find
+      # a value
+      # @return [Any, nil]
+      def find_best_value_for(hash, *args)
+        raise ArgumentError, 'First argument must be hash' unless hash.is_a? Hash
+
+        field = args.find do |f|
+          !hash.dig(*f).nil? && !hash.dig(*f).empty?
+        rescue TypeError
+          false
+        end
+
+        hash.dig(*field) if field
+      end
+
+      # Raise an exception if the value is required but empty
+      #
+      # @param :value [String,nil]
+      # @param :exception [Object]
+      def value_is_required!(value, exception)
+        raise exception if value.nil? || value.empty?
+      rescue exception => e
+        raise if strict?
+
+        Jekyll.logger.warn 'ActivityPub:', e.message
+      end
+
+      # Generates an absolute URL if not empty
+      #
+      # @param :url [String,nil]
+      # @return [nil,String]
+      def conditional_absolute_url(url)
+        return if url.nil? || url.empty?
+
+        absolute_url url
+      end
+    end
+  end
+end

data/lib/jekyll/activity_pub/host_meta.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require 'jekyll/page_without_a_file'
+require_relative 'helper'
+
+module Jekyll
+  module ActivityPub
+    # Host meta
+    #
+    # https://www.rfc-editor.org/rfc/rfc6415
+    class HostMeta < Jekyll::PageWithoutAFile
+      include Helper
+
+      # Initialize with default data
+      #
+      # @param :site [Jekyll::Site]
+      # @param :base [String]
+      # @param :dir [String]
+      # @param :name [String]
+      def initialize(site, webfinger, base = '', dir = '.well-known', name = 'host-meta')
+        super(site, base, dir, name)
+
+        @webfinger = webfinger
+        @context = StubContext.new(registers: { site: site })
+
+        trigger_hooks :post_init
+      end
+
+      def permalink
+        '.well-known/host-meta'
+      end
+
+      # @return [String]
+      def content
+        @content ||=
+          <<~CONTENT
+            <?xml version="1.0" encoding="UTF-8"?>
+            <XRD xmlns="http://docs.oasis-open.org/ns/xri/xrd-1.0">
+              <Link rel="lrdd" template="#{absolute_url @webfinger.url}"/>
+            </XRD>
+          CONTENT
+      end
+    end
+  end
+end

data/lib/jekyll/activity_pub/image.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+module Jekyll
+  module ActivityPub
+    # Represents an Image
+    class Image
+      include Helper
+
+      attr_reader :data
+
+      # Initialize with default data
+      #
+      # @param :site [Jekyll::Site]
+      # @param :path [Path]
+      # @param :description [String]
+      def initialize(site, path, description = nil)
+        @context = StubContext.new(registers: { site: site })
+
+        @data = {
+          'type' => 'Image',
+          'mediaType' => "image/#{File.extname(path).sub('.', '')}",
+          'url' => absolute_url(path),
+          'name' => description.to_s
+        }
+
+        trigger_hooks :post_init
+      end
+    end
+  end
+end

data/lib/jekyll/activity_pub/notifier.rb

@@ -0,0 +1,268 @@
+# frozen_string_literal: true
+
+require 'pathname'
+require 'httparty'
+require 'distributed_press/v1/social/client'
+require_relative 'errors'
+require_relative 'create'
+require_relative 'update'
+require_relative 'delete'
+
+module Jekyll
+  module ActivityPub
+    # Long term store for notifications.
+    #
+    # Needs to be a singleton so we can use the same data across all of
+    # Jekyll's build process.
+    class Notifier
+      # An struct that responds to a #url method
+      PseudoObject = Struct.new(:url, keyword_init: true)
+
+      class << self
+        # Set the site and initialize data
+        #
+        # @param :site [Jekyll::Site]
+        # @return [Jekyll::Site]
+        def site=(site)
+          @@site = site.tap do |s|
+            s.data['activity_pub'] ||= {}
+            s.data['activity_pub']['notifications'] ||= {}
+          end
+        end
+
+        # Save the public key URL for later
+        #
+        # @param :url [String]
+        def public_key_url=(url)
+          data['public_key_url'] = url
+        end
+
+        # Public key URL
+        #
+        # @return [String,nil]
+        def public_key_url
+          data['public_key_url']
+        end
+
+        def actor=(actor)
+          data['actor'] = actor
+        end
+
+        def actor
+          data['actor']
+        end
+
+        def actor_url=(url)
+          data['actor_url'] = url
+        end
+
+        def actor_url
+          data['actor_url']
+        end
+
+        # Send notifications
+        #
+        # 1. Wait for public key propagation
+        # 2. Create/update inbox
+        # 3. Send create, update, and delete
+        def notify!
+          # TODO: request several times with a timeout
+          response = HTTParty.get(public_key_url)
+
+          unless response.ok?
+            raise NotificationError,
+                  "Could't fetch public key (#{response.code}: #{response.message})"
+          end
+
+          unless client.private_key.compare? OpenSSL::Pkey::RSA.new(response.body)
+            raise NotificationError, "Public key at #{public_key_url} differs from local version"
+          end
+
+          base_endpoint = "/v1/#{actor}/"
+          outbox_endpoint = "#{base_endpoint}/outbox/"
+          actor_object = PseudoObject.new(url: actor_url)
+
+          # Create inbox
+          # TODO: Send keypair
+          client.post(endpoint: base_endpoint, body: {})
+
+          # Remove notifications already performed and notify
+          data['notifications'].reject do |object_url, status|
+            done? object_url, status
+          end.each do |object_url, status|
+            process_object(outbox_endpoint, actor_object, PseudoObject.new(url: object_url), status)
+          end
+
+          # Store everything for later
+          save
+        end
+
+        # @return [Jekyll::Site]
+        def site
+          @@site
+        end
+
+        # Return data
+        #
+        # @return [Hash]
+        def data
+          @@data ||= site.data['activity_pub']
+        end
+
+        # Removes an activity if it was previously created
+        #
+        # @param :path [String]
+        # @return [Hash]
+        def delete(path)
+          action(path, 'delete') if exist? path
+        end
+
+        # Updates an activity if it was previously created
+        #
+        # @param :path [String]
+        # @return [Hash]
+        def update(path)
+          action(path, 'update') if exist? path
+        end
+
+        # Creates an activity
+        #
+        # @param :path [String]
+        # @return [Hash]
+        def create(path)
+          action(path, 'create')
+        end
+
+        # Check if activity existed
+        #
+        # @param :path [String]
+        # @return [Boolean]
+        def exist?(path)
+          data['notifications'].key? path_relative_to_dest(path)
+        end
+
+        # Stores data back to a file and optionally commits it
+        #
+        # @return [nil]
+        def save
+          # TODO: Send warning if CI is detected
+          Jekyll.logger.info 'ActivityPub:', "Saving data to #{relative_path}"
+
+          FileUtils.mkdir_p(File.dirname(path))
+
+          File.open(path, 'w') do |f|
+            f.flock(File::LOCK_EX)
+            f.rewind
+            f.write(YAML.dump(data))
+            f.flush
+            f.truncate(f.pos)
+          end
+
+          if ENV['JEKYLL_ENV'] == 'production' && site.respond_to?(:repository)
+            site.staged_files << relative_path
+            site.repository.commit 'ActivityPub'
+          end
+
+          nil
+        end
+
+        # Returns the path for the storage
+        #
+        # @return [String]
+        def path
+          @@path ||= site.in_source_dir(site.config['data_dir'], 'activity_pub.yml')
+        end
+
+        # Storage path relative to site source
+        #
+        # @return [String]
+        def relative_path
+          @@relative_path ||= Pathname.new(path).relative_path_from(site.source).to_s
+        end
+
+        private
+
+        # Finds the private key path on config
+        #
+        # @return [String, nil]
+        def private_key_path
+          @@private_key_path ||= site.config['activity_pub_private_key']
+        end
+
+        # Returns the private key
+        #
+        # @return [String, nil]
+        def private_key
+          @@private_key ||= File.read private_key_path
+        rescue StandardError
+          Jekyll.logger.warn 'ActivityPub:', 'There\'s an issue with your private key'
+          raise
+        end
+
+        # @return [Hash]
+        def config
+          @@config ||= site.config['activity_pub'] || {}
+        end
+
+        def client
+          @@client ||= DistributedPress::V1::Social::Client.new(
+            private_key_pem: private_key,
+            url: config['url'],
+            public_key_url: public_key_url
+          )
+        end
+
+        # Run action
+        #
+        # @param :path [String]
+        # @param :action [String]
+        # @return [Hash]
+        def action(path, action)
+          path = path_relative_to_dest(path)
+
+          data['notifications'][path] ||= {}
+          data['notifications'][path]['action'] = action.to_s
+        end
+
+        # Paths are relative to site destination
+        #
+        # @param :path [String]
+        # @return [String]
+        def path_relative_to_dest(path)
+          Pathname.new(site.in_dest_dir(path)).relative_path_from(site.dest).to_s
+        end
+
+        # Detects if an action was already done
+        def done?(url, status)
+          (status['action'] == 'done').tap do |done|
+            Jekyll.logger.debug('ActivityPub:', "Skipping notification for #{url}") if done
+          end
+        end
+
+        # Turns an object into an activity and notifies outbox
+        #
+        # @param :endpoint [String]
+        # @param :actor [PseudoObject]
+        # @param :object [PseudoObject]
+        # @param :status [Hash]
+        # @return [nil]
+        def process_object(endpoint, actor, object, status)
+          action = status['action']
+          activity = Object.const_get(action.capitalize).new(site, actor, object)
+
+          if (response = client.post(endpoint: endpoint, body: activity)).ok?
+            status['action'] = 'done'
+            status["#{action}d_at"] = Time.now.to_i
+          else
+            Jekyll.logger.warn 'ActivityPub:',
+                               "Couldn't perform #{action} for #{object_url} (#{response.code}: #{response.message})"
+          end
+
+          nil
+        rescue NameError
+          Jekyll.logger.warn 'ActivityPub:', "Action \"#{action}\" for #{url} unrecognized, ignoring."
+        end
+      end
+    end
+  end
+end

data/lib/jekyll/activity_pub/ordered_collection.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+require 'jekyll/page'
+require_relative 'helper'
+require_relative 'ordered_collection_page'
+
+module Jekyll
+  module ActivityPub
+    # An ordered collection of activities
+    class OrderedCollection < Jekyll::Page
+      include Helper
+
+      # Initialize with default data
+      #
+      # @param :site [Jekyll::Site]
+      # @param :base [String]
+      # @param :dir [String]
+      # @param :name [String]
+      def initialize(site, base = '', dir = '', name = 'ordered_collection.jsonld')
+        @context = StubContext.new(registers: { site: site })
+
+        super
+
+        trigger_hooks :post_init
+      end
+
+      def read_yaml(*)
+        self.data = {
+          '@context' => 'https://www.w3.org/ns/activitystreams',
+          'id' => absolute_url(url),
+          'type' => 'OrderedCollection',
+          'totalItems' => 0,
+          'orderedItems' => []
+        }
+      end
+
+      alias original_content content
+
+      # Paginates the collection if it has too many activities
+      #
+      # @return [String]
+      def content
+        @content ||=
+          begin
+            order_items!
+
+            return original_content unless always_paginate? || paginable?
+            return original_content if data['orderedItems'].empty?
+
+            paged_data = data.dup
+            pages = paginate(paged_data.delete('orderedItems'))
+
+            assign_links! pages
+
+            paged_data['first'] = absolute_url(pages.first.url)
+            paged_data['last'] = absolute_url(pages.last.url)
+
+            paged_data.to_json
+          end
+      end
+
+      private
+
+      # Items per page
+      #
+      # @return [Integer]
+      def items_per_page
+        @items_per_page ||=
+          begin
+            from_config = site.config.dig('activity_pub', 'items_per_page').to_i
+            if from_config.positive?
+              from_config
+            else
+              Jekyll.logger.warn 'ActivityPub:', 'Items per page option empty or not valid, using 20 items per page'
+              20
+            end
+          end
+      end
+
+      # Force pagination
+      #
+      # @return [Boolean]
+      def always_paginate?
+        !!site.config.dig('activity_pub', 'always_paginate')
+      end
+
+      # Item count is higher than items per page
+      #
+      # @return [Boolean]
+      def paginable?
+        data['orderedItems'].size > items_per_page
+      end
+
+      # Generate pages
+      #
+      # @param :items [Array]
+      # @return [Array]
+      def paginate(items)
+        [].tap do |pages|
+          total_pages = items.count / items_per_page
+
+          items.each_slice(items_per_page).each_with_index do |paged_items, i|
+            OrderedCollectionPage.new(site, self, nil, basename, "#{total_pages - i}.jsonld").tap do |page|
+              page.data['orderedItems'] = paged_items
+              site.pages << page
+              pages << page
+            end
+          end
+        end
+      end
+
+      # Assign previous and next links between pages
+      #
+      # @param :pages [Array]
+      # @return [nil]
+      def assign_links!(pages)
+        pages.reduce do |previous, current|
+          current.data['prev'] = absolute_url(previous.url)
+          previous.data['next'] = absolute_url(current.url)
+
+          current
+        end
+
+        nil
+      end
+
+      # Sort items
+      #
+      # @return [nil]
+      def order_items!
+        data['orderedItems'].sort! do |a, b|
+          b.data['published'] <=> a.data['published']
+        end
+      end
+    end
+  end
+end

data/lib/jekyll/activity_pub/ordered_collection_page.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require 'jekyll/page'
+require_relative 'helper'
+
+module Jekyll
+  module ActivityPub
+    # A collection of activities
+    class OrderedCollectionPage < Jekyll::Page
+      include Helper
+
+      attr_reader :outbox
+
+      # Initialize with default data
+      #
+      # @param :site [Jekyll::Site]
+      # @param :outbox [Jekyll::ActivityPub::Outbox]
+      # @param :base [String]
+      # @param :dir [String]
+      # @param :name [String]
+      def initialize(site, outbox, base = '', dir = 'outbox', name = 'page.jsonld')
+        @context = StubContext.new(registers: { site: site })
+        @outbox = outbox
+
+        super(site, base, dir, name)
+
+        trigger_hooks :post_init
+      end
+
+      def read_yaml(*)
+        self.data = {
+          '@context' => 'https://www.w3.org/ns/activitystreams',
+          'id' => absolute_url(url),
+          'type' => 'OrderedCollectionPage',
+          'partOf' => absolute_url(outbox.url),
+          'orderedItems' => []
+        }
+      end
+    end
+  end
+end

data/lib/jekyll/activity_pub/outbox.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative 'ordered_collection'
+
+module Jekyll
+  module ActivityPub
+    # A collection of activities
+    class Outbox < OrderedCollection
+      # Initialize with default data
+      #
+      # @param :site [Jekyll::Site]
+      # @param :actor [Jekyll::ActivityPub::Actor]
+      # @param :base [String]
+      # @param :dir [String]
+      # @param :name [String]
+      def initialize(site, actor, base = '', dir = '', name = 'outbox.jsonld')
+        super(site, base, dir, name)
+
+        actor.data['outbox'] = absolute_url(url)
+
+        trigger_hooks :post_init
+      end
+    end
+  end
+end