diaspora_federation 0.1.9 → 0.2.0

data/lib/diaspora_federation/entities.rb

@@ -12,6 +12,7 @@ require "diaspora_federation/entities/related_entity"
 
 # abstract types
 require "diaspora_federation/entities/post"
+require "diaspora_federation/entities/signable"
 require "diaspora_federation/entities/relayable"
 
 # types
@@ -19,6 +20,7 @@ require "diaspora_federation/entities/profile"
 require "diaspora_federation/entities/person"
 require "diaspora_federation/entities/contact"
 require "diaspora_federation/entities/account_deletion"
+require "diaspora_federation/entities/account_migration"
 
 require "diaspora_federation/entities/participation"
 require "diaspora_federation/entities/like"

data/lib/diaspora_federation/entity.rb

@@ -90,7 +90,6 @@ module DiasporaFederation
     # {http://www.rubydoc.info/gems/nokogiri/Nokogiri/XML/Element Nokogiri::XML::Element}s
     #
     # @see Nokogiri::XML::Node.to_xml
-    # @see XmlPayload#pack
     #
     # @return [Nokogiri::XML::Element] root element containing properties as child elements
     def to_xml
@@ -109,10 +108,21 @@ module DiasporaFederation
     # @param [Nokogiri::XML::Element] root_node xml nodes
     # @return [Entity] instance
     def self.from_xml(root_node)
-      raise ArgumentError, "only Nokogiri::XML::Element allowed" unless root_node.instance_of?(Nokogiri::XML::Element)
-      raise InvalidRootNode, "'#{root_node.name}' can't be parsed by #{name}" unless root_node.name == entity_name
+      from_hash(*xml_parser_class.new(self).parse(root_node))
+    end
+
+    private_class_method def self.xml_parser_class
+      DiasporaFederation::Parsers::XmlParser
+    end
 
-      populate_entity(root_node)
+    # Creates an instance of self by parsing a hash in the format of JSON serialized object (which usually means
+    # data from a parsed JSON input).
+    def self.from_json(json_hash)
+      from_hash(*json_parser_class.new(self).parse(json_hash))
+    end
+
+    private_class_method def self.json_parser_class
+      DiasporaFederation::Parsers::JsonParser
     end
 
     # Makes an underscored, lowercase form of the class name
@@ -121,7 +131,7 @@ module DiasporaFederation
     #
     # @return [String] entity name
     def self.entity_name
-      name.rpartition("::").last.tap do |word|
+      class_name.tap do |word|
         word.gsub!(/(.)([A-Z])/, '\1_\2')
         word.downcase!
       end
@@ -144,16 +154,52 @@ module DiasporaFederation
       Entities.const_get(class_name)
     end
 
+    # @return [String] class name as string
+    def self.class_name
+      name.rpartition("::").last
+    end
+
     # @return [String] string representation of this object
     def to_s
-      "#{self.class.name.rpartition('::').last}#{":#{guid}" if respond_to?(:guid)}"
+      "#{self.class.class_name}#{":#{guid}" if respond_to?(:guid)}"
+    end
+
+    # Renders entity to a hash representation of the entity JSON format
+    # @return [Hash] Returns a hash that is equal by structure to the entity in JSON format
+    def to_json
+      {
+        entity_type: self.class.entity_name,
+        entity_data: json_data
+      }
+    end
+
+    # Creates an instance of self, filling it with data from a provided hash of properties.
+    #
+    # The hash format is described as following:<br>
+    # 1) Properties of the hash are representation of the entity's class properties<br>
+    # 2) Keys of the hash must be of Symbol type<br>
+    # 3) Possible values of the hash properties depend on the types of the entity's class properties<br>
+    # 4) Basic properties, such as booleans, strings, integers and timestamps are represented by values of respective
+    # formats<br>
+    # 5) Nested hashes and arrays of hashes are allowed to represent nested entities. Nested hashes follow the same
+    # format as the parent hash.<br>
+    # 6) Besides, the nested entities can be passed in the hash as already instantiated objects of the respective type.
+    #
+    # @param [Hash] properties_hash A hash of the expected format
+    # @return [Entity] an instance
+    def self.from_hash(properties_hash)
+      new(properties_hash)
     end
 
     private
 
     def validate_missing_props(entity_data)
       missing_props = self.class.missing_props(entity_data)
-      raise ValidationError, "missing required properties: #{missing_props.join(', ')}" unless missing_props.empty?
+      return if missing_props.empty?
+
+      obj_str = "#{self.class.class_name}#{":#{entity_data[:guid]}" if entity_data.has_key?(:guid)}" \
+                "#{" from #{entity_data[:author]}" if entity_data.has_key?(:author)}"
+      raise ValidationError, "#{obj_str}: Missing required properties: #{missing_props.join(', ')}"
     end
 
     def setable?(name, val)
@@ -168,7 +214,7 @@ module DiasporaFederation
     end
 
     def setable_string?(type, val)
-      %i(string integer boolean).include?(type) && val.respond_to?(:to_s)
+      %i[string integer boolean].include?(type) && val.respond_to?(:to_s)
     end
 
     def setable_nested?(type, val)
@@ -209,7 +255,7 @@ module DiasporaFederation
       errors = validator.errors.map do |prop, rule|
         "property: #{prop}, value: #{public_send(prop).inspect}, rule: #{rule[:rule]}, with params: #{rule[:params]}"
       end
-      "Failed validation for properties: #{errors.join(' | ')}"
+      "Failed validation for #{self}#{" from #{author}" if respond_to?(:author)} for properties: #{errors.join(' | ')}"
     end
 
     # @return [Hash] hash with all properties
@@ -225,7 +271,7 @@ module DiasporaFederation
 
     def normalize_property(name, value)
       case self.class.class_props[name]
-      when :string, :integer, :boolean
+      when :string
         value.to_s
       when :timestamp
         value.nil? ? "" : value.utc.iso8601
@@ -245,8 +291,8 @@ module DiasporaFederation
     end
 
     def add_property_to_xml(doc, root_element, name, value)
-      if value.is_a? String
-        root_element << simple_node(doc, name, value)
+      if [String, TrueClass, FalseClass, Integer].any? {|c| value.is_a? c }
+        root_element << simple_node(doc, name, value.to_s)
       else
         # call #to_xml for each item and append to root
         [*value].compact.each do |item|
@@ -258,102 +304,34 @@ module DiasporaFederation
 
     # Create simple node, fill it with text and append to root
     def simple_node(doc, name, value)
-      xml_name = self.class.xml_names[name]
-      Nokogiri::XML::Element.new(xml_name ? xml_name.to_s : name, doc).tap do |node|
+      Nokogiri::XML::Element.new(name.to_s, doc).tap do |node|
         node.content = value.gsub(INVALID_XML_REGEX, "\uFFFD") unless value.empty?
       end
     end
 
-    # @param [Nokogiri::XML::Element] root_node xml nodes
-    # @return [Entity] instance
-    private_class_method def self.populate_entity(root_node)
-      new(entity_data(root_node))
-    end
-
-    # @param [Nokogiri::XML::Element] root_node xml nodes
-    # @return [Hash] entity data
-    private_class_method def self.entity_data(root_node)
-      class_props.map {|name, type|
-        value = parse_element_from_node(name, type, root_node)
-        [name, value] unless value.nil?
-      }.compact.to_h
-    end
-
-    # @param [String] name property name to parse
-    # @param [Class, Symbol] type target type to parse
-    # @param [Nokogiri::XML::Element] root_node XML node to parse
-    # @return [Object] parsed data
-    private_class_method def self.parse_element_from_node(name, type, root_node)
-      if type.instance_of?(Symbol)
-        parse_string_from_node(name, type, root_node)
-      elsif type.instance_of?(Array)
-        parse_array_from_node(type.first, root_node)
-      elsif type.ancestors.include?(Entity)
-        parse_entity_from_node(type, root_node)
-      end
-    end
+    # Generates a hash with entity properties which is put to the "entity_data"
+    # field of a JSON serialized object.
+    # @return [Hash] object properties in JSON format
+    def json_data
+      enriched_properties.map {|key, value|
+        type = self.class.class_props[key]
 
-    # Create simple entry in data hash
-    #
-    # @param [String] name xml tag to parse
-    # @param [Class, Symbol] type target type to parse
-    # @param [Nokogiri::XML::Element] root_node XML root_node to parse
-    # @return [String] data
-    private_class_method def self.parse_string_from_node(name, type, root_node)
-      node = root_node.xpath(name.to_s)
-      node = root_node.xpath(xml_names[name].to_s) if node.empty?
-      parse_string(type, node.first.text) if node.any?
-    end
-
-    # @param [Symbol] type target type to parse
-    # @param [String] text data as string
-    # @return [String, Boolean, Integer, Time] data
-    private_class_method def self.parse_string(type, text)
-      case type
-      when :timestamp
-        begin
-          Time.parse(text).utc
-        rescue
-          nil
+        if !value.nil? && type.instance_of?(Class) && value.respond_to?(:to_json)
+          entity_data = value.to_json
+          [key, entity_data] unless entity_data.nil?
+        elsif type.instance_of?(Array)
+          entity_data = value.nil? ? nil : value.map(&:to_json)
+          [key, entity_data] unless entity_data.nil?
+        else
+          [key, value]
         end
-      when :integer
-        text.to_i if text =~ /\A\d+\z/
-      when :boolean
-        return true if text =~ /\A(true|t|yes|y|1)\z/i
-        false if text =~ /\A(false|f|no|n|0)\z/i
-      else
-        text
-      end
-    end
-
-    # Create an entry in the data hash for the nested entity
-    #
-    # @param [Class] type target type to parse
-    # @param [Nokogiri::XML::Element] root_node XML node to parse
-    # @return [Entity] parsed child entity
-    private_class_method def self.parse_entity_from_node(type, root_node)
-      node = root_node.xpath(type.entity_name)
-      type.from_xml(node.first) if node.any? && node.first.children.any?
-    end
-
-    # Collect all nested children of that type and create an array in the data hash
-    #
-    # @param [Class] type target type to parse
-    # @param [Nokogiri::XML::Element] root_node XML node to parse
-    # @return [Array<Entity>] array with parsed child entities
-    private_class_method def self.parse_array_from_node(type, root_node)
-      node = root_node.xpath(type.entity_name)
-      node.select {|child| child.children.any? }.map {|child| type.from_xml(child) } unless node.empty?
+      }.compact.to_h
     end
 
     # Raised, if entity is not valid
     class ValidationError < RuntimeError
     end
 
-    # Raised, if the root node doesn't match the class name
-    class InvalidRootNode < RuntimeError
-    end
-
     # Raised, if the entity name in the XML is invalid
     class InvalidEntityName < RuntimeError
     end

data/lib/diaspora_federation/federation/fetcher.rb

@@ -13,7 +13,7 @@ module DiasporaFederation
         response = HttpClient.get(url)
         raise "Failed to fetch #{url}: #{response.status}" unless response.success?
 
-        magic_env_xml = Nokogiri::XML::Document.parse(response.body).root
+        magic_env_xml = Nokogiri::XML(response.body).root
         magic_env = Salmon::MagicEnvelope.unenvelop(magic_env_xml)
         Receiver::Public.new(magic_env).receive
       rescue => e

data/lib/diaspora_federation/federation/receiver.rb

@@ -11,7 +11,7 @@ module DiasporaFederation
         magic_env = if legacy
                       Salmon::Slap.from_xml(data)
                     else
-                      magic_env_xml = Nokogiri::XML::Document.parse(data).root
+                      magic_env_xml = Nokogiri::XML(data).root
                       Salmon::MagicEnvelope.unenvelop(magic_env_xml)
                     end
         Public.new(magic_env).receive

data/lib/diaspora_federation/federation/sender/hydra_wrapper.rb

@@ -1,3 +1,5 @@
+require "typhoeus"
+
 module DiasporaFederation
   module Federation
     module Sender
@@ -17,12 +19,21 @@ module DiasporaFederation
             method:         :post,
             verbose:        DiasporaFederation.http_verbose,
             cainfo:         DiasporaFederation.certificate_authorities,
-            forbid_reuse:   true,
-            headers:        {
-              "Expect"            => "",
-              "Transfer-Encoding" => "",
-              "User-Agent"        => DiasporaFederation.http_user_agent
-            }
+            forbid_reuse:   true
+          }
+        end
+
+        def self.xml_headers
+          @xml_headers ||= {
+            "Content-Type" => "application/magic-envelope+xml",
+            "User-Agent"   => DiasporaFederation.http_user_agent
+          }
+        end
+
+        def self.json_headers
+          @json_headers ||= {
+            "Content-Type" => "application/json",
+            "User-Agent"   => DiasporaFederation.http_user_agent
           }
         end
 
@@ -36,13 +47,18 @@ module DiasporaFederation
           @urls_to_retry = []
         end
 
-        # Prepares and inserts job into the hydra queue
+        # Prepares and inserts a public MagicEnvelope job into the hydra queue
         # @param [String] url the receive-url for the xml
-        # @param [String] xml xml salmon message
-        def insert_job(url, xml)
-          request = Typhoeus::Request.new(url, HydraWrapper.hydra_opts.merge(body: {xml: xml}))
-          prepare_request(request)
-          hydra.queue(request)
+        # @param [String] xml MagicEnvelope xml
+        def insert_magic_env_request(url, xml)
+          insert_job(url, HydraWrapper.hydra_opts.merge(body: xml, headers: HydraWrapper.xml_headers))
+        end
+
+        # Prepares and inserts a private encrypted MagicEnvelope job into the hydra queue
+        # @param [String] url the receive-url for the message
+        # @param [String] json encrypted MagicEnvelope json
+        def insert_enc_magic_env_request(url, json)
+          insert_job(url, HydraWrapper.hydra_opts.merge(body: json, headers: HydraWrapper.json_headers))
         end
 
         # Sends all queued messages
@@ -54,6 +70,15 @@ module DiasporaFederation
 
         private
 
+        # Prepares and inserts job into the hydra queue
+        # @param [String] url the receive-url for the message
+        # @param [Hash] options request options
+        def insert_job(url, options)
+          request = Typhoeus::Request.new(url, options)
+          prepare_request(request)
+          hydra.queue(request)
+        end
+
         # @return [Typhoeus::Hydra] hydra
         def hydra
           @hydra ||= Typhoeus::Hydra.new(max_concurrency: DiasporaFederation.http_concurrency)

data/lib/diaspora_federation/federation/sender.rb

@@ -11,7 +11,7 @@ module DiasporaFederation
       # @return [Array<String>] url to retry
       def self.public(sender_id, obj_str, urls, xml)
         hydra = HydraWrapper.new(sender_id, obj_str)
-        urls.each {|url| hydra.insert_job(url, xml) }
+        urls.each {|url| hydra.insert_magic_env_request(url, xml) }
         hydra.send
       end
 
@@ -23,7 +23,7 @@ module DiasporaFederation
       # @return [Hash] targets to retry
       def self.private(sender_id, obj_str, targets)
         hydra = HydraWrapper.new(sender_id, obj_str)
-        targets.each {|url, xml| hydra.insert_job(url, xml) }
+        targets.each {|url, json| hydra.insert_enc_magic_env_request(url, json) }
         hydra.send.map {|url| [url, targets[url]] }.to_h
       end
     end

data/lib/diaspora_federation/parsers/base_parser.rb

@@ -0,0 +1,61 @@
+module DiasporaFederation
+  module Parsers
+    # +BaseParser+ is an abstract class which is used for defining parsers for different
+    # deserialization methods.
+    class BaseParser
+      # @param [Class] entity_type type of DiasporaFederation::Entity that we want to parse with that parser instance
+      def initialize(entity_type)
+        @entity_type = entity_type
+      end
+
+      # This method is used to parse input with a serialized object data. It returns
+      # a comprehensive data which must be enough to construct a DiasporaFederation::Entity instance.
+      #
+      # Since parser method output is normally passed to a .from_hash method of an entity
+      # as arguments using * operator, the parse method must return an array of a size matching the number
+      # of arguments of .from_hash method of the entity type we link with
+      # @abstract
+      def parse(*)
+        raise NotImplementedError.new("you must override this method when creating your own parser")
+      end
+
+      private
+
+      # @param [Symbol] type target type to parse
+      # @param [String] text data as string
+      # @return [String, Boolean, Integer, Time] data
+      def parse_string(type, text)
+        case type
+        when :timestamp
+          begin
+            Time.parse(text).utc
+          rescue
+            nil
+          end
+        when :integer
+          text.to_i if text =~ /\A\d+\z/
+        when :boolean
+          return true if text =~ /\A(true|t|yes|y|1)\z/i
+          false if text =~ /\A(false|f|no|n|0)\z/i
+        else
+          text
+        end
+      end
+
+      def assert_parsability_of(entity_class)
+        return if entity_class == entity_type.entity_name
+        raise InvalidRootNode, "'#{entity_class}' can't be parsed by #{entity_type.name}"
+      end
+
+      attr_reader :entity_type
+
+      def class_properties
+        entity_type.class_props
+      end
+
+      # Raised, if the root node doesn't match the class name
+      class InvalidRootNode < RuntimeError
+      end
+    end
+  end
+end

data/lib/diaspora_federation/parsers/json_parser.rb

@@ -0,0 +1,60 @@
+module DiasporaFederation
+  module Parsers
+    # This is a parser of JSON serialized object. JSON object format is defined by
+    # JSON schema which is available at https://diaspora.github.io/diaspora_federation/schemas/federation_entities.json.
+    # TODO: We must publish the schema at a real URL
+    class JsonParser < BaseParser
+      # @see BaseParser#parse
+      # @param [Hash] json_hash A hash acquired by running JSON.parse with JSON serialized entity
+      # @return [Array[1]] comprehensive data for an entity instantiation
+      def parse(json_hash)
+        from_json_sanity_validation(json_hash)
+        parse_entity_data(json_hash["entity_data"])
+      end
+
+      private
+
+      def parse_entity_data(entity_data)
+        hash = entity_data.map {|key, value|
+          property = entity_type.find_property_for_xml_name(key)
+          if property
+            type = entity_type.class_props[property]
+            [property, parse_element_from_value(type, entity_data[key])]
+          else
+            [key, value]
+          end
+        }.to_h
+
+        [hash]
+      end
+
+      def parse_element_from_value(type, value)
+        return if value.nil?
+        if %i[integer boolean timestamp].include?(type) && !value.is_a?(String)
+          value
+        elsif type.instance_of?(Symbol)
+          parse_string(type, value)
+        elsif type.instance_of?(Array)
+          raise DeserializationError, "Expected array for #{type}" unless value.respond_to?(:map)
+          value.map {|element|
+            type.first.from_json(element)
+          }
+        elsif type.ancestors.include?(Entity)
+          type.from_json(value)
+        end
+      end
+
+      def from_json_sanity_validation(json_hash)
+        missing = %w[entity_type entity_data].map {|prop|
+          prop if json_hash[prop].nil?
+        }.compact.join(", ")
+        raise DeserializationError, "Required properties are missing in JSON object: #{missing}" unless missing.empty?
+        assert_parsability_of(json_hash["entity_type"])
+      end
+
+      # Raised when the format of the input JSON data doesn't match the parser's expectations
+      class DeserializationError < RuntimeError
+      end
+    end
+  end
+end

data/lib/diaspora_federation/parsers/relayable_json_parser.rb

@@ -0,0 +1,25 @@
+module DiasporaFederation
+  module Parsers
+    # This is a parser of JSON serialized object, that is normally used for parsing data of relayables.
+    # Assumed format differs from the usual entity by additional "property_order" property which is used to
+    # compute signatures deterministically.
+    # Input JSON for this parser is expected to match "/definitions/relayable" subschema of the JSON schema at
+    # https://diaspora.github.io/diaspora_federation/schemas/federation_entities.json.
+    class RelayableJsonParser < JsonParser
+      # @see JsonParser#parse
+      # @see BaseParser#parse
+      # @return [Array[2]] comprehensive data for an entity instantiation
+      def parse(json_hash)
+        super.push(json_hash["property_order"])
+      end
+
+      private
+
+      def from_json_sanity_validation(json_hash)
+        super
+        return unless json_hash["property_order"].nil?
+        raise DeserializationError, "Required property is missing in JSON object: property_order"
+      end
+    end
+  end
+end

data/lib/diaspora_federation/parsers/relayable_xml_parser.rb

@@ -0,0 +1,22 @@
+module DiasporaFederation
+  module Parsers
+    # This is a parser of XML serialized object that is normally used for parsing data of relayables.
+    # Explanations about the XML data format can be found
+    # {https://diaspora.github.io/diaspora_federation/federation/xml_serialization.html here}.
+    # Specific features of relayables are described
+    # {https://diaspora.github.io/diaspora_federation/federation/relayable.html here}.
+    #
+    # @see https://diaspora.github.io/diaspora_federation/federation/xml_serialization.html XML Serialization
+    #   documentation
+    # @see https://diaspora.github.io/diaspora_federation/federation/relayable.html Relayable documentation
+    class RelayableXmlParser < XmlParser
+      # @see XmlParser#parse
+      # @see BaseParser#parse
+      # @return [Array[2]] comprehensive data for an entity instantiation
+      def parse(*args)
+        hash = super[0]
+        [hash, hash.keys]
+      end
+    end
+  end
+end

data/lib/diaspora_federation/parsers/xml_parser.rb

@@ -0,0 +1,84 @@
+module DiasporaFederation
+  module Parsers
+    # This is a parser of XML serialized object.
+    # Explanations about the XML data format can be found
+    # {https://diaspora.github.io/diaspora_federation/federation/xml_serialization.html here}.
+    # @see https://diaspora.github.io/diaspora_federation/federation/xml_serialization.html XML Serialization
+    #   documentation
+    class XmlParser < BaseParser
+      # @see BaseParser#parse
+      # @param [Nokogiri::XML::Element] root_node root XML node of the XML representation of the entity
+      # @return [Array[1]] comprehensive data for an entity instantiation
+      def parse(root_node)
+        from_xml_sanity_validation(root_node)
+
+        hash = root_node.element_children.map {|child|
+          xml_name = child.name
+          property = entity_type.find_property_for_xml_name(xml_name)
+          if property
+            type = class_properties[property]
+            value = parse_element_from_node(xml_name, type, root_node)
+            [property, value]
+          else
+            [xml_name, child.text]
+          end
+        }.to_h
+
+        [hash]
+      end
+
+      private
+
+      # @param [String] name property name to parse
+      # @param [Class, Symbol] type target type to parse
+      # @param [Nokogiri::XML::Element] root_node XML node to parse
+      # @return [Object] parsed data
+      def parse_element_from_node(name, type, root_node)
+        if type.instance_of?(Symbol)
+          parse_string_from_node(name, type, root_node)
+        elsif type.instance_of?(Array)
+          parse_array_from_node(type.first, root_node)
+        elsif type.ancestors.include?(Entity)
+          parse_entity_from_node(type, root_node)
+        end
+      end
+
+      # Create simple entry in data hash
+      #
+      # @param [String] name xml tag to parse
+      # @param [Class, Symbol] type target type to parse
+      # @param [Nokogiri::XML::Element] root_node XML root_node to parse
+      # @return [String] data
+      def parse_string_from_node(name, type, root_node)
+        node = root_node.xpath(name.to_s)
+        node = root_node.xpath(xml_names[name].to_s) if node.empty?
+        parse_string(type, node.first.text) if node.any?
+      end
+
+      # Create an entry in the data hash for the nested entity
+      #
+      # @param [Class] type target type to parse
+      # @param [Nokogiri::XML::Element] root_node XML node to parse
+      # @return [Entity] parsed child entity
+      def parse_entity_from_node(type, root_node)
+        node = root_node.xpath(type.entity_name)
+        type.from_xml(node.first) if node.any? && node.first.children.any?
+      end
+
+      # Collect all nested children of that type and create an array in the data hash
+      #
+      # @param [Class] type target type to parse
+      # @param [Nokogiri::XML::Element] root_node XML node to parse
+      # @return [Array<Entity>] array with parsed child entities
+      def parse_array_from_node(type, root_node)
+        node = root_node.xpath(type.entity_name)
+        node.select {|child| child.children.any? }.map {|child| type.from_xml(child) } unless node.empty?
+      end
+
+      def from_xml_sanity_validation(root_node)
+        raise ArgumentError, "only Nokogiri::XML::Element allowed" unless root_node.instance_of?(Nokogiri::XML::Element)
+        assert_parsability_of(root_node.name)
+      end
+    end
+  end
+end

data/lib/diaspora_federation/parsers.rb

@@ -0,0 +1,13 @@
+module DiasporaFederation
+  # This namespace contains parsers which are used to deserialize federation entities
+  # objects from supported formats (XML, JSON) to objects of DiasporaFederation::Entity
+  # classes
+  module Parsers
+  end
+end
+
+require "diaspora_federation/parsers/base_parser"
+require "diaspora_federation/parsers/json_parser"
+require "diaspora_federation/parsers/xml_parser"
+require "diaspora_federation/parsers/relayable_json_parser"
+require "diaspora_federation/parsers/relayable_xml_parser"

data/lib/diaspora_federation/properties_dsl.rb

@@ -127,7 +127,7 @@ module DiasporaFederation
     end
 
     def property_type_valid?(type)
-      %i(string integer boolean timestamp).include?(type)
+      %i[string integer boolean timestamp].include?(type)
     end
 
     # Checks if the type extends {Entity}

data/lib/diaspora_federation/salmon/encrypted_magic_envelope.rb

@@ -54,7 +54,7 @@ module DiasporaFederation
         key = encoded_key.map {|k, v| [k, Base64.decode64(v)] }.to_h
 
         xml = AES.decrypt(encrypted_json["encrypted_magic_envelope"], key["key"], key["iv"])
-        Nokogiri::XML::Document.parse(xml).root
+        Nokogiri::XML(xml).root
       end
     end
   end