distributed-press-api-client 0.3.1 → 0.4.0rc3

data/lib/distributed_press/v1/social/dereferencer.rb.orig

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+require 'addressable'
+require_relative 'reference'
+
+class DistributedPress
+  module V1
+    module Social
+      # Fetches ActivityStreams from different instances by
+      # instantiating clients.
+      class Dereferencer
+        # @return [DistributedPress::V1::Social::Client]
+        attr_reader :client
+
+        REFERENTIABLE_ATTRIBUTES =
+          %w[
+            actor
+            owner
+            attributedTo
+            cc
+            inReplyTo
+            object
+            replies
+            to
+            publicKey
+
+            alsoKnownAs
+            devices
+            featured
+            featuredTags
+            followers
+            following
+            inbox
+            movedTo
+            outbox
+
+            first
+            items
+            next
+            orderedItems
+            partOf
+            prev
+          ].freeze
+
+        # @param :client [DistributedPress::V1::Social::Client]
+        def initialize(client:)
+          @client = client
+          @parser =
+            proc do |body, format|
+              next HTTParty::Parser.call(body, format || :plain) unless body&.starts_with? '{'
+
+              HTTParty::Parser.call(body, :json).tap do |object|
+                reference_object! object
+              end
+            end
+        end
+
+        # Fetch a URI
+        #
+        # @param :uri [String, Addressable::URI]
+        # @return [HTTParty::Response]
+        def get(uri:)
+          uri = uris(uri)
+
+          clients(uri).get(endpoint: uri.path, parser: @parser)
+        end
+
+        # Gets a client for a URI
+        #
+        # @param :uri [Addressable::URI]
+        # @return [DistributedPress::V1::Social::Client]
+        def clients(uri)
+          @clients ||= {}
+          @clients[uri.origin] ||=
+            client.class.new(
+              url: uri.origin,
+              public_key_url: client.public_key_url,
+              private_key_pem: client.private_key.to_s,
+              logger: client.logger,
+              cache_store: client.class.cache_store
+            )
+        end
+
+        # Gets a reference for a URI and indexes it by the complete
+        # and normalized URI
+        #
+        # @param :uri [String, Addressable::URI]
+        # @return [DistributedPress::V1::Social::Reference]
+        def references(uri)
+          @references ||= {}
+          @references[uri.to_s] ||= Reference.new(uri: uri.to_s, dereferencer: self)
+        end
+
+        # Make sure we're getting a normalized Addressable::URI
+        #
+        # @param :uri [String, Addressable::URI]
+        # @return [Addressable::URI]
+        def uris(uri)
+          @uris ||= {}
+          @uris[uri.to_s] ||=
+            (if uri.is_a? Addressable::URI
+               uri
+             else
+               Addressable::URI.parse(uri)
+             end).normalize
+        end
+
+        def reference_object!(object)
+          REFERENTIABLE_ATTRIBUTES.each do |attribute|
+            next unless object.key? attribute
+
+            case object[attribute]
+            when Array
+              object[attribute].map! do |o|
+                case o
+                when Hash
+                  reference_object!(o)
+                  o
+                when String then references(uris(o))
+                end
+              end
+            when Hash
+              reference_object!(object[attribute])
+            when String
+              object[attribute] = references(uris(object[attribute]))
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/distributed_press/v1/social/hook.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require_relative 'client'
+require_relative 'schemas/webhook'
+
+class DistributedPress
+  module V1
+    module Social
+      # Manages the actor's hooks on the Social Inbox
+      class Hook
+        class Error < StandardError; end
+        class ValidationError < Error; end
+        class EventNotValidError < Error; end
+
+        ACCEPT = %w[text/plain].freeze
+        CONTENT_TYPE = 'text/plain'
+        EVENTS = %w[moderationqueued onapproved onrejected].freeze
+
+        # @return [DistributedPress::V1::Social::Client]
+        attr_reader :client
+
+        # @return [String]
+        attr_reader :actor
+
+        # @param :client [DistributedPress::V1::Social::Client]
+        # @param :actor [String]
+        def initialize(client:, actor:)
+          @client = client
+          @actor = actor
+          # The serializer validates the body format and raises an
+          # exception if it contains errors.
+          @serializer = proc do |body|
+            body.tap do |b|
+              next if b.errors.empty?
+
+              raise ValidationError, body.errors.to_h.map do |key, messages|
+                messages.map do |message|
+                  "#{key} #{message}"
+                end
+              end.flatten.join(', ')
+            end.to_h.to_json
+          end
+
+          # XXX: format is nil but should be :json
+          @parser = proc do |body, format|
+            next HTTParty::Parser.call(body, format || :plain) unless body.starts_with? '{'
+
+            json = HTTParty::Parser.call(body, :json)
+
+            DistributedPress::V1::Social::Schemas::Webhook.new.call(json)
+          end
+        end
+
+        # Gets a hook and validates return, or 404 when not found
+        #
+        # @param :event [String]
+        # @return [HTTParty::Response]
+        def get(event:)
+          validate_event! event
+
+          client.get(endpoint: "#{endpoint}/#{event}", parser: @parser)
+        end
+
+        # Creates a webhook
+        #
+        # @param :event [String]
+        # @param :hook [DistributedPress::V1::Social::Schemas::Webhook]
+        # @return [HTTParty::Response]
+        def put(event:, hook:)
+          validate_event! event
+
+          client.put(endpoint: "#{endpoint}/#{event}", body: hook, serializer: @serializer, parser: @parser)
+        end
+
+        # Removes a hook for an event
+        #
+        # @param :event [String]
+        # @return [HTTParty::Response]
+        def delete(event:)
+          validate_event! event
+
+          client.delete(endpoint: "#{endpoint}/#{event}", serializer: @serializer, parser: @parser)
+        end
+
+        # Endpoint
+        #
+        # @return [String]
+        def endpoint
+          @endpoint ||= "/v1/#{actor}/hooks"
+        end
+
+        private
+
+        def validate_event!(event)
+          raise EventNotValidError, "#{event} must be one of #{EVENTS.join(', ')}" unless EVENTS.include? event
+        end
+      end
+    end
+  end
+end

data/lib/distributed_press/v1/social/inbox.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require 'uri'
+require_relative 'client'
+
+class DistributedPress
+  module V1
+    module Social
+      # Manages the actor's inbox on the Social Inbox
+      class Inbox
+        # @return [DistributedPress::V1::Social::Client]
+        attr_reader :client
+
+        # @return [String]
+        attr_reader :actor
+
+        # @param :client [DistributedPress::V1::Social::Client]
+        # @param :actor [String]
+        def initialize(client:, actor:)
+          @client = client
+          @actor = actor
+        end
+
+        # Get the actor's inbox
+        #
+        # @return [HTTParty::Response]
+        def get
+          client.get(endpoint: endpoint)
+        end
+
+        # Send an activity to the actor's inbox. This is typically done
+        # by other actors though, not ourselves, so it could be used to
+        # send directly to another Actor's Social Inbox.
+        #
+        # @param :activity [Hash]
+        # @return [HTTParty::Response]
+        def post(activity:)
+          client.post(endpoint: endpoint, body: activity)
+        end
+
+        # Reject an activity queued on the inbox
+        #
+        # @param :id [String] Activity ID
+        # @return [HTTParty::Response]
+        def reject(id:)
+          client.delete(endpoint: "#{endpoint}/#{URI.encode_uri_component(id)}")
+        end
+
+        # Accept an activity queued on the inbox
+        #
+        # @param :id [String] Activity ID
+        # @return [HTTParty::Response]
+        def accept(id:)
+          client.post(endpoint: "#{endpoint}/#{URI.encode_uri_component(id)}", body: {})
+        end
+
+        # Inbox
+        #
+        # @return [String]
+        def endpoint
+          @endpoint ||= "/v1/#{actor}/inbox"
+        end
+      end
+    end
+  end
+end

data/lib/distributed_press/v1/social/outbox.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require 'uri'
+require_relative 'client'
+
+class DistributedPress
+  module V1
+    module Social
+      # Manages the actor's outbox on the Social Inbox
+      class Outbox
+        # @return [DistributedPress::V1::Social::Client]
+        attr_reader :client
+
+        # @return [String]
+        attr_reader :actor
+
+        # @param :client [DistributedPress::V1::Social::Client]
+        # @param :actor [String]
+        def initialize(client:, actor:)
+          @client = client
+          @actor = actor
+        end
+
+        # Send an activity to the actor's outbox.  The Social Inbox will
+        # take care of sending it to the audiences.
+        #
+        # @param :activity [Hash]
+        # @return [HTTParty::Response]
+        def post(activity:)
+          client.post(endpoint: endpoint, body: activity)
+        end
+
+        # Get an activity queued on the outbox
+        #
+        # @param :id [String] Activity ID
+        # @return [HTTParty::Response]
+        def get(id:)
+          client.get(endpoint: "#{endpoint}/#{URI.encode_uri_component(id)}")
+        end
+
+        # Outbox
+        #
+        # @return [String]
+        def endpoint
+          @endpoint ||= "/v1/#{actor}/outbox"
+        end
+      end
+    end
+  end
+end

data/lib/distributed_press/v1/social/reference.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+class DistributedPress
+  module V1
+    module Social
+      # A lazy loaded reference to a remote object that can access its
+      # attributes directly.
+      class Reference
+        extend Forwardable
+
+        # @return [String]
+        attr_reader :uri
+
+        # @return [DistributedPress::V1::Social::Dereferencer]
+        attr_reader :dereferencer
+
+        # @param :uri [String]
+        # @param :dereferencer [DistributedPress::V1::Social::Dereferencer]
+        def initialize(uri:, dereferencer:)
+          @uri = uri
+          @dereferencer = dereferencer
+        end
+
+        # Fetches the remote object once
+        #
+        # @return [HTTParty::Response]
+        def object
+          @object ||= dereferencer.get(uri: uri)
+        end
+
+        def inspect
+          "#{self.class.name}(#{uri})"
+        end
+
+        def_delegators :object, :[], :dig, :to_h, :to_json
+      end
+    end
+  end
+end

data/lib/distributed_press/v1/social/referenced_object.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+class DistributedPress
+  module V1
+    module Social
+      # An object with external references
+      class ReferencedObject
+        extend Forwardable
+
+        REFERENTIABLE_ATTRIBUTES =
+          %w[
+            actor
+            owner
+            attributedTo
+            cc
+            inReplyTo
+            object
+            replies
+            to
+            publicKey
+
+            alsoKnownAs
+            devices
+            featured
+            featuredTags
+            followers
+            following
+            inbox
+            movedTo
+            outbox
+
+            first
+            items
+            next
+            orderedItems
+            partOf
+            prev
+          ].freeze
+
+        attr_reader :object
+        attr_reader :dereferencer
+        attr_reader :referenced
+
+        def_delegators :referenced, :[], :dig, :to_h, :to_json
+
+        def initialize(object:, dereferencer:)
+          @object = object
+          @dereferencer = dereferencer
+          @referenced = HTTParty::ModuleInheritableAttributes.hash_deep_dup(object)
+          reference_object! referenced
+        end
+
+        def _dump(_)
+          Marshal.dump([object, dereferencer])
+        end
+
+        def self._load(array)
+          object, dereferencer = Marshal.load(array)
+
+          new(object: object, dereferencer: dereferencer)
+        end
+
+        private
+
+        def reference_object!(object)
+          REFERENTIABLE_ATTRIBUTES.each do |attribute|
+            next unless object.key? attribute
+
+            case object[attribute]
+            when Array
+              object[attribute].map! do |o|
+                case o
+                when Hash
+                  reference_object!(o)
+                  o
+                when String then dereferencer.references(dereferencer.uris(o))
+                end
+              end
+            when Hash
+              reference_object!(object[attribute])
+            when String
+              object[attribute] = dereferencer.references(dereferencer.uris(object[attribute]))
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/distributed_press/v1/social/schemas/webhook.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require 'dry-schema'
+require_relative '../../../../dry/schema/processor_decorator'
+require_relative '../../../../dry/schema/result_decorator'
+
+class DistributedPress
+  module V1
+    module Social
+      # WebhookSchema
+      module Schemas
+        class Webhook < Dry::Schema::JSON
+          METHODS = %w[GET POST PUT DELETE].freeze
+
+          define do
+            required(:url).value(:uri_rfc3986?)
+            required(:method).value(included_in?: METHODS)
+            required(:headers).hash
+          end
+        end
+      end
+    end
+  end
+end

data/lib/distributed_press/v1/social/signed_headers.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+class DistributedPress
+  module V1
+    module Social
+      # Headers need to be signed by knowing the HTTP method (verb) and
+      # path.  Since we're using caching, we need to change the
+      # signature after it's changed.
+      class SignedHeaders < Hash
+        # Signing algorithm
+        #
+        # @todo is it possible to use other algorithms?
+        ALGORITHM = 'rsa-sha256'
+
+        # Required by HTTP Signatures
+        REQUEST_TARGET = '(request-target)'
+
+        # Headers included in the signature
+        # rubocop:disable Style/MutableConstant
+        SIGNABLE_HEADERS = [REQUEST_TARGET, 'Host', 'Date', 'Digest']
+        # rubocop:enable Style/MutableConstant
+
+        # @return [HTTParty::Request]
+        attr_accessor :request
+
+        # @return [OpenSSL::PKey::RSA]
+        attr_accessor :private_key
+
+        # @return [String]
+        attr_accessor :public_key_url
+
+        # Takes advantage of HTTParty::Request.setup_raw_request running
+        # to_hash on the headers, so we sign as soon as we're ready to
+        # send the request.
+        #
+        # @return [Hash]
+        def to_hash
+          request_target!
+          sign_headers!
+
+          # xxx: converts to an actual Hash to facilitate marshaling
+          super.to_h
+        end
+
+        private
+
+        # @return [String]
+        def verb
+          request.http_method.name.split('::').last.downcase
+        end
+
+        def request_target!
+          self[REQUEST_TARGET] = "#{verb} #{request.path}"
+        end
+
+        # HTTP Signatures
+        #
+        # @see {https://docs.joinmastodon.org/spec/security/}
+        # @param :headers [Hash]
+        def sign_headers!
+          self['Signature'] = {
+            'keyId' => public_key_url,
+            'algorithm' => ALGORITHM,
+            'headers' => signable_headers,
+            'signature' => signed_headers
+          }.map do |key, value|
+            "#{key}=\"#{value}\""
+          end.join(',')
+
+          delete REQUEST_TARGET
+
+          nil
+        end
+
+        # List of headers to be signed, removing headers that don't
+        # exist on the request.
+        #
+        # @return [String]
+        def signable_headers
+          (SIGNABLE_HEADERS & keys).join(' ').downcase
+        end
+
+        # Sign headers
+        #
+        # @return [String]
+        def signed_headers
+          Base64.strict_encode64(
+            private_key.sign(
+              OpenSSL::Digest.new('SHA256'),
+              signature_content
+            )
+          )
+        end
+
+        # Generates a string to be signed
+        #
+        # @return [String]
+        def signature_content
+          slice(*SIGNABLE_HEADERS).map do |key, value|
+            "#{key.downcase}: #{value}"
+          end.join("\n")
+        end
+      end
+    end
+  end
+end

data/lib/distributed_press/version.rb

@@ -3,5 +3,5 @@
 # API client
 class DistributedPress
   # Version
-  VERSION = '0.3.1'
+  VERSION = '0.4.0rc3'
 end

data/lib/dry/schema/processor_decorator.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require 'dry/schema/processor'
+
+module Dry
+  module Schema
+    # Include the processor as Result option so we can deserialize
+    # later.
+    module ProcessorDecorator
+      def self.included(base)
+        base.class_eval do
+          # Add the processor to the result so we can deserialize it
+          # later
+          def call(input)
+            Result.new(input.dup, message_compiler: message_compiler, processor: self) do |result|
+              steps.call(result)
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+Dry::Schema::Processor.include Dry::Schema::ProcessorDecorator

data/lib/dry/schema/result_decorator.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require 'dry/schema/processor'
+
+module Dry
+  module Schema
+    # This decorator allows to serialize Dry::Schema::Result objects
+    # by storing the data and processor so they can be run again during
+    # deserialization.
+    module ResultDecorator
+      def self.included(base)
+        base.class_eval do
+          option :processor
+
+          def _dump(_)
+            Marshal.dump(
+              {
+                processor: processor.class,
+                data: to_h
+              }
+            )
+          end
+
+          def self._load(data)
+            data = Marshal.load(data)
+
+            data[:processor].new.call(data[:data])
+          end
+        end
+      end
+    end
+  end
+end
+
+Dry::Schema::Result.include Dry::Schema::ResultDecorator