diaspora_federation 0.0.12 → 0.0.13

data/lib/diaspora_federation/entities/relayable_retraction.rb

@@ -38,11 +38,11 @@ module DiasporaFederation
       #   @return [String] target type
       property :target_type
 
-      # @!attribute [r] diaspora_id
+      # @!attribute [r] author
       #   The diaspora ID of the person who deletes a relayable
-      #   @see Person#diaspora_id
+      #   @see Person#author
       #   @return [String] diaspora ID
-      property :diaspora_id, xml_name: :sender_handle
+      property :author, xml_name: :sender_handle
 
       # @!attribute [r] target_author_signature
       #   Contains a signature of the entity using the private key of the
@@ -53,43 +53,44 @@ module DiasporaFederation
       #   @return [String] target author signature
       property :target_author_signature, default: nil
 
-      # Generates XML and updates signatures
-      # @see Entity#to_xml
-      # @return [Nokogiri::XML::Element] root element containing properties as child elements
-      def to_xml
-        entity_xml.tap do |xml|
-          hash = to_h
-          RelayableRetraction.update_signatures!(hash)
-          xml.at_xpath("target_author_signature").content = hash[:target_author_signature]
-          xml.at_xpath("parent_author_signature").content = hash[:parent_author_signature]
-        end
+      # use only {Retraction} for receive
+      # @return [Retraction] instance as normal retraction
+      def to_retraction
+        Retraction.new(author: author, target_guid: target_guid, target_type: target_type)
+      end
+
+      private
+
+      # @param [Nokogiri::XML::Element] root_node xml nodes
+      # @return [Retraction] instance
+      def self.populate_entity(root_node)
+        super(root_node).to_retraction
       end
+      private_class_method :populate_entity
 
-      # Adds signatures to a given hash with the keys of the author and the parent
-      # if the signatures are not in the hash yet and if the keys are available.
+      # It updates also the signatures with the keys of the author and the parent
+      # if the signatures are not there yet and if the keys are available.
       #
-      # @param [Hash] hash hash given for a signing
-      def self.update_signatures!(hash)
-        target_author = DiasporaFederation.callbacks.trigger(
-          :fetch_entity_author_id_by_guid,
-          hash[:target_type],
-          hash[:target_guid]
-        )
-        pkey = DiasporaFederation.callbacks.trigger(:fetch_private_key_by_diaspora_id, hash[:diaspora_id])
+      # @return [Hash] xml elements with updated signatures
+      def xml_elements
+        target_author = DiasporaFederation.callbacks.trigger(:fetch_entity_author_id_by_guid, target_type, target_guid)
+        privkey = DiasporaFederation.callbacks.trigger(:fetch_private_key_by_diaspora_id, author)
 
-        fill_required_signature(target_author, pkey, hash) unless pkey.nil?
+        super.tap do |xml_elements|
+          fill_required_signature(target_author, privkey, xml_elements) unless privkey.nil?
+        end
       end
 
-      def self.fill_required_signature(target_author, pkey, hash)
-        if target_author == hash[:diaspora_id] && hash[:target_author_signature].nil?
-          hash[:target_author_signature] =
-            Signing.sign_with_key(SignedRetraction.apply_signable_exceptions(hash), pkey)
-        elsif target_author != hash[:diaspora_id] && hash[:parent_author_signature].nil?
-          hash[:parent_author_signature] =
-            Signing.sign_with_key(SignedRetraction.apply_signable_exceptions(hash), pkey)
+      # @param [String] target_author the author of the entity to retract
+      # @param [OpenSSL::PKey::RSA] privkey private key of sender
+      # @param [Hash] hash hash given for a signing
+      def fill_required_signature(target_author, privkey, hash)
+        if target_author == author && target_author_signature.nil?
+          hash[:target_author_signature] = SignedRetraction.sign_with_key(privkey, self)
+        elsif target_author != author && parent_author_signature.nil?
+          hash[:parent_author_signature] = SignedRetraction.sign_with_key(privkey, self)
         end
       end
-      private_class_method :fill_required_signature
     end
   end
 end

data/lib/diaspora_federation/entities/request.rb

@@ -4,18 +4,32 @@ module DiasporaFederation
     # when he starts sharing with another user.
     #
     # @see Validators::RequestValidator
+    # @deprecated will be replaced with {Contact}
     class Request < Entity
-      # @!attribute [r] sender_id
+      # @!attribute [r] author
       #   The diaspora ID of the person who shares his profile
-      #   @see Person#diaspora_id
+      #   @see Person#author
       #   @return [String] sender ID
-      property :sender_id, xml_name: :sender_handle
+      property :author, xml_name: :sender_handle
 
-      # @!attribute [r] recipient_id
+      # @!attribute [r] recipient
       #   The diaspora ID of the person who will be shared with
-      #   @see Person#diaspora_id
+      #   @see Validation::Rule::DiasporaId
       #   @return [String] recipient ID
-      property :recipient_id, xml_name: :recipient_handle
+      property :recipient, xml_name: :recipient_handle
+
+      # use only {Contact} for receive
+      # @return [Contact] instance as contact
+      def to_contact
+        Contact.new(author: author, recipient: recipient)
+      end
+
+      # @param [Nokogiri::XML::Element] root_node xml nodes
+      # @return [Retraction] instance
+      def self.populate_entity(root_node)
+        super(root_node).to_contact
+      end
+      private_class_method :populate_entity
     end
   end
 end

data/lib/diaspora_federation/entities/reshare.rb

@@ -4,11 +4,13 @@ module DiasporaFederation
     #
     # @see Validators::ReshareValidator
     class Reshare < Entity
-      # @!attribute [r] diaspora_id
+      include Post
+
+      # @!attribute [r] root_author
       #   The diaspora ID of the person who posted the original post
-      #   @see Person#diaspora_id
+      #   @see Person#author
       #   @return [String] diaspora ID
-      property :root_diaspora_id # inconsistent, everywhere else it's "handle"
+      property :root_author, xml_name: :root_diaspora_id
 
       # @!attribute [r] root_guid
       #   guid of the original post
@@ -16,34 +18,10 @@ module DiasporaFederation
       #   @return [String] root guid
       property :root_guid
 
-      # @!attribute [r] guid
-      #   a random string of at least 16 chars.
-      #   @see Validation::Rule::Guid
-      #   @see StatusMessage#guid
-      #   @return [String] guid
-      property :guid
-
-      # @!attribute [r] diaspora_id
-      #   The diaspora ID of the person who reshares a post
-      #   @see Person#diaspora_id
-      #   @return [String] diaspora ID
-      property :diaspora_id, xml_name: :diaspora_handle
-
       # @!attribute [r] public
       #   has no meaning at the moment
       #   @return [Boolean] public
       property :public, default: true # always true? (we only reshare public posts)
-
-      # @!attribute [r] created_at
-      #   reshare entity creation time
-      #   @return [Time] creation time
-      property :created_at, default: -> { Time.now.utc }
-
-      # @!attribute [r] provider_display_name
-      #   a string that describes a means by which a user has posted the reshare
-      #   @see StatusMessage#provider_display_name
-      #   @return [String] provider display name
-      property :provider_display_name, default: nil
     end
   end
 end

data/lib/diaspora_federation/entities/retraction.rb

@@ -4,17 +4,17 @@ module DiasporaFederation
     #
     # @see Validators::RetractionValidator
     class Retraction < Entity
+      # @!attribute [r] author
+      #   The diaspora ID of the person who deletes the entity
+      #   @see Person#author
+      #   @return [String] diaspora ID
+      property :author, xml_name: :diaspora_handle
+
       # @!attribute [r] target_guid
       #   guid of the entity to be deleted
       #   @return [String] target guid
       property :target_guid, xml_name: :post_guid
 
-      # @!attribute [r] diaspora_id
-      #   The diaspora ID of the person who deletes the entity
-      #   @see Person#diaspora_id
-      #   @return [String] diaspora ID
-      property :diaspora_id, xml_name: :diaspora_handle
-
       # @!attribute [r] target_type
       #   A string describing the type of the target.
       #   @return [String] target type

data/lib/diaspora_federation/entities/signed_retraction.rb

@@ -18,11 +18,11 @@ module DiasporaFederation
       #   @return [String] target type
       property :target_type
 
-      # @!attribute [r] diaspora_id
+      # @!attribute [r] author
       #   The diaspora ID of the person who deletes a post
-      #   @see Person#diaspora_id
+      #   @see Person#author
       #   @return [String] diaspora ID
-      property :diaspora_id, xml_name: :sender_handle
+      property :author, xml_name: :sender_handle
 
       # @!attribute [r] author_signature
       #   Contains a signature of the entity using the private key of the author of a post
@@ -30,36 +30,42 @@ module DiasporaFederation
       #   @return [String] author signature
       property :target_author_signature, default: nil
 
-      # Generates XML and updates signatures
-      # @see Entity#to_xml
-      # @return [Nokogiri::XML::Element] root element containing properties as child elements
-      def to_xml
-        entity_xml.tap do |xml|
-          hash = to_h
-          SignedRetraction.update_signatures!(hash)
+      # use only {Retraction} for receive
+      # @return [Retraction] instance as normal retraction
+      def to_retraction
+        Retraction.new(author: author, target_guid: target_guid, target_type: target_type)
+      end
 
-          xml.at_xpath("target_author_signature").content = hash[:target_author_signature]
-        end
+      # Create signature for a retraction
+      # @param [OpenSSL::PKey::RSA] privkey private key of sender
+      # @param [SignedRetraction, RelayableRetraction] ret the retraction to sign
+      # @return [String] a Base64 encoded signature of the retraction with the key
+      def self.sign_with_key(privkey, ret)
+        Base64.strict_encode64(privkey.sign(Relayable::DIGEST, [ret.target_guid, ret.target_type].join(";")))
+      end
+
+      private
+
+      # @param [Nokogiri::XML::Element] root_node xml nodes
+      # @return [Retraction] instance
+      def self.populate_entity(root_node)
+        super(root_node).to_retraction
       end
+      private_class_method :populate_entity
 
-      # Adds signature to a given hash with the key of the author
-      # if the signature is not in the hash yet and if the key is available.
+      # It updates also the signatures with the keys of the author and the parent
+      # if the signatures are not there yet and if the keys are available.
       #
-      # @param [Hash] data hash given for a signing
-      def self.update_signatures!(data)
-        if data[:target_author_signature].nil?
-          pkey = DiasporaFederation.callbacks.trigger(:fetch_private_key_by_diaspora_id, data[:diaspora_id])
-          data[:target_author_signature] = Signing.sign_with_key(apply_signable_exceptions(data), pkey) unless pkey.nil?
+      # @return [Hash] xml elements with updated signatures
+      def xml_elements
+        super.tap do |xml_elements|
+          xml_elements[:target_author_signature] = target_author_signature || sign_with_author.to_s
         end
       end
 
-      # Deletes :diaspora_id (xml_name: sender_handle) from the hash in order to compute
-      # a signature since it is included from signable_string for SignedRetraction and RelayableRetraction
-      #
-      # @param [Hash] data hash of the retraction properties
-      # @return [Hash] hash copy without :diaspora_id member
-      def self.apply_signable_exceptions(data)
-        data.dup.tap {|data| data.delete(:diaspora_id) }
+      def sign_with_author
+        privkey = DiasporaFederation.callbacks.trigger(:fetch_private_key_by_diaspora_id, author)
+        SignedRetraction.sign_with_key(privkey, self) unless privkey.nil?
       end
     end
   end

data/lib/diaspora_federation/entities/status_message.rb

@@ -4,6 +4,8 @@ module DiasporaFederation
     #
     # @see Validators::StatusMessageValidator
     class StatusMessage < Entity
+      include Post
+
       # @!attribute [r] raw_message
       #   text of the status message composed by the user
       #   @return [String] text of the status message
@@ -24,32 +26,10 @@ module DiasporaFederation
       #   @return [Entities::Poll] poll
       entity :poll, Entities::Poll, default: nil
 
-      # @!attribute [r] guid
-      #   a random string of at least 16 chars.
-      #   @see Validation::Rule::Guid
-      #   @return [String] status message guid
-      property :guid
-
-      # @!attribute [r] diaspora_id
-      #   The diaspora ID of the person who posts the status message
-      #   @see Person#diaspora_id
-      #   @return [String] diaspora ID
-      property :diaspora_id, xml_name: :diaspora_handle
-
       # @!attribute [r] public
       #   shows whether the status message is visible to everyone or only to some aspects
       #   @return [Boolean] is it public
       property :public, default: false
-
-      # @!attribute [r] created_at
-      #   status message entity creation time
-      #   @return [Time] creation time
-      property :created_at, default: -> { Time.now.utc }
-
-      # @!attribute [r] provider_display_name
-      #   a string that describes a means by which a user has posted the status message
-      #   @return [String] provider display name
-      property :provider_display_name, default: nil
     end
   end
 end

data/lib/diaspora_federation/entity.rb

@@ -47,17 +47,18 @@ module DiasporaFederation
     # @note Attributes not defined as part of the class definition ({PropertiesDSL#property},
     #       {PropertiesDSL#entity}) get discarded silently.
     #
-    # @param [Hash] data
+    # @param [Hash] data entity data
     # @return [Entity] new instance
     def initialize(data)
       raise ArgumentError, "expected a Hash" unless data.is_a?(Hash)
-      missing_props = self.class.missing_props(data)
+      entity_data = self.class.resolv_aliases(data)
+      missing_props = self.class.missing_props(entity_data)
       unless missing_props.empty?
         raise ArgumentError, "missing required properties: #{missing_props.join(', ')}"
       end
 
-      self.class.default_values.merge(data).each do |k, v|
-        instance_variable_set("@#{k}", nilify(v)) if setable?(k, v)
+      self.class.default_values.merge(entity_data).each do |name, value|
+        instance_variable_set("@#{name}", nilify(value)) if setable?(name, value)
       end
 
       freeze
@@ -67,7 +68,7 @@ module DiasporaFederation
     # Returns a Hash representing this Entity (attributes => values)
     # @return [Hash] entity data (mostly equal to the hash used for initialization).
     def to_h
-      self.class.class_prop_names.each_with_object({}) do |prop, hash|
+      self.class.class_props.keys.each_with_object({}) do |prop, hash|
         hash[prop] = public_send(prop)
       end
     end
@@ -80,10 +81,31 @@ module DiasporaFederation
     #
     # @return [Nokogiri::XML::Element] root element containing properties as child elements
     def to_xml
-      entity_xml
+      doc = Nokogiri::XML::DocumentFragment.new(Nokogiri::XML::Document.new)
+      Nokogiri::XML::Element.new(self.class.entity_name, doc).tap do |root_element|
+        xml_elements.each do |name, value|
+          add_property_to_xml(doc, root_element, name, value)
+        end
+      end
+    end
+
+    # Construct a new instance of the given Entity and populate the properties
+    # with the attributes found in the XML.
+    # Works recursively on nested Entities and Arrays thereof.
+    #
+    # @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
+
+      populate_entity(root_node)
     end
 
     # Makes an underscored, lowercase form of the class name
+    #
+    # @see .entity_class
+    #
     # @return [String] entity name
     def self.entity_name
       name.rpartition("::").last.tap do |word|
@@ -92,29 +114,42 @@ module DiasporaFederation
       end
     end
 
+    # Transform the given String from the lowercase underscored version to a
+    # camelized variant and returns the Class constant.
+    #
+    # @see .entity_name
+    #
+    # @param [String] entity_name "snake_case" class name
+    # @return [Class] entity class
+    def self.entity_class(entity_name)
+      raise InvalidEntityName, "'#{entity_name}' is invalid" unless entity_name =~ /^[a-z]*(_[a-z]*)*$/
+      class_name = entity_name.sub(/^[a-z]/, &:upcase)
+      class_name.gsub!(/_([a-z])/) { Regexp.last_match[1].upcase }
+
+      raise UnknownEntity, "'#{class_name}' not found" unless Entities.const_defined?(class_name)
+
+      Entities.const_get(class_name)
+    end
+
     private
 
     def setable?(name, val)
-      prop_def = self.class.class_props.find {|p| p[:name] == name }
-      return false if prop_def.nil? # property undefined
+      type = self.class.class_props[name]
+      return false if type.nil? # property undefined
 
-      setable_string?(prop_def, val) || setable_nested?(prop_def, val) || setable_multi?(prop_def, val)
+      setable_string?(type, val) || setable_nested?(type, val) || setable_multi?(type, val)
     end
 
-    def setable_string?(definition, val)
-      (definition[:type] == String && val.respond_to?(:to_s))
+    def setable_string?(type, val)
+      type == String && val.respond_to?(:to_s)
     end
 
-    def setable_nested?(definition, val)
-      t = definition[:type]
-      (t.is_a?(Class) && t.ancestors.include?(Entity) && val.is_a?(Entity))
+    def setable_nested?(type, val)
+      type.is_a?(Class) && type.ancestors.include?(Entity) && val.is_a?(Entity)
     end
 
-    def setable_multi?(definition, val)
-      t = definition[:type]
-      (t.instance_of?(Array) &&
-        val.instance_of?(Array) &&
-        val.all? {|v| v.instance_of?(t.first) })
+    def setable_multi?(type, val)
+      type.instance_of?(Array) && val.instance_of?(Array) && val.all? {|v| v.instance_of?(type.first) }
     end
 
     def nilify(value)
@@ -138,40 +173,104 @@ module DiasporaFederation
       "Failed validation for properties: #{errors.join(' | ')}"
     end
 
-    # Serialize the Entity into XML elements
-    # @return [Nokogiri::XML::Element] root node
-    def entity_xml
-      doc = Nokogiri::XML::DocumentFragment.new(Nokogiri::XML::Document.new)
-      Nokogiri::XML::Element.new(self.class.entity_name, doc).tap do |root_element|
-        self.class.class_props.each do |prop_def|
-          add_property_to_xml(doc, prop_def, root_element)
-        end
-      end
+    def xml_elements
+      Hash[to_h.map {|name, value| [name, self.class.class_props[name] == String ? value.to_s : value] }]
     end
 
-    def add_property_to_xml(doc, prop_def, root_element)
-      property = prop_def[:name]
-      type = prop_def[:type]
-      if type == String
-        root_element << simple_node(doc, prop_def[:xml_name], property)
+    def add_property_to_xml(doc, root_element, name, value)
+      if value.is_a? String
+        root_element << simple_node(doc, name, value)
       else
         # call #to_xml for each item and append to root
-        [*public_send(property)].compact.each do |item|
+        [*value].compact.each do |item|
           root_element << item.to_xml
         end
       end
     end
 
     # create simple node, fill it with text and append to root
-    def simple_node(doc, name, property)
-      Nokogiri::XML::Element.new(name.to_s, doc).tap do |node|
-        data = public_send(property).to_s
-        node.content = data unless data.empty?
+    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|
+        node.content = value unless value.empty?
       end
     end
 
+    # @param [Nokogiri::XML::Element] root_node xml nodes
+    # @return [Entity] instance
+    def self.populate_entity(root_node)
+      entity_data = Hash[class_props.map {|name, type|
+        [name, parse_element_from_node(name, type, root_node)]
+      }]
+
+      new(entity_data)
+    end
+    private_class_method :populate_entity
+
+    # @param [String] name property name to parse
+    # @param [Class] type target type to parse
+    # @param [Nokogiri::XML::Element] root_node XML node to parse
+    # @return [Object] parsed data
+    def self.parse_element_from_node(name, type, root_node)
+      if type == String
+        parse_string_from_node(name, 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
+    private_class_method :parse_element_from_node
+
+    # create simple entry in data hash
+    #
+    # @param [String] name xml tag to parse
+    # @param [Nokogiri::XML::Element] root_node XML root_node to parse
+    # @return [String] data
+    def self.parse_string_from_node(name, root_node)
+      node = root_node.xpath(name.to_s)
+      node = root_node.xpath(xml_names[name].to_s) if node.empty?
+      node.first.text if node.any?
+    end
+    private_class_method :parse_string_from_node
+
+    # 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 self.parse_entity_from_node(type, root_node)
+      node = root_node.xpath(type.entity_name)
+      type.from_xml(node.first) if node.any?
+    end
+    private_class_method :parse_entity_from_node
+
+    # 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 self.parse_array_from_node(type, root_node)
+      node = root_node.xpath(type.entity_name)
+      node.map {|child| type.from_xml(child) }
+    end
+    private_class_method :parse_array_from_node
+
     # 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
+
+    # Raised, if the entity contained within the XML cannot be mapped to a
+    # defined {Entity} subclass.
+    class UnknownEntity < RuntimeError
+    end
   end
 end