occi-core 4.3.6 → 5.0.0.alpha.1

data/lib/occi/core/parsers/json_parser.rb

@@ -0,0 +1,128 @@
+module Occi
+  module Core
+    module Parsers
+      # Contains all JSON-related classes and modules. This
+      # module houses functionality transforming various internal
+      # instances from basic JSON rendering.
+      #
+      # @author Boris Parak <parak@cesnet.cz>
+      module Json; end
+    end
+  end
+end
+
+# Load class-specific parsing primitives
+Dir[File.join(File.dirname(__FILE__), 'json', '*.rb')].each { |file| require file.gsub('.rb', '') }
+
+module Occi
+  module Core
+    module Parsers
+      # Implementes components necessary to parse all required instance types
+      # from `JSON` or `JSON`-like format.
+      #
+      # @author Boris Parak <parak@cesnet.cz>
+      class JsonParser < BaseParser
+        # Media type constants
+        MEDIA_TYPES = %w[application/occi+json application/json].freeze
+
+        # Parses entities from the given body/headers. Only kinds, mixins, and actions already declared
+        # in the model are allowed.
+        #
+        # @param body [String] raw `String`-like body as provided by the transport protocol
+        # @param headers [Hash] raw headers as provided by the transport protocol
+        # @param expectation [Class] expected class of the returned instance(s)
+        # @return [Set] set of instances
+        def entities(body, _headers = nil, expectation = nil)
+          expectation ||= Occi::Core::Entity
+          type = validate_entities! body
+
+          entity_parser = Json::Entity.new(model: model)
+          entities = entity_parser.json body, type
+          entities.each do |entity|
+            unless entity.is_a?(expectation)
+              raise Occi::Core::Errors::ParsingError, "#{self.class} -> Given entity isn't #{expectation}"
+            end
+          end
+
+          entities
+        end
+
+        # Parses action instances from the given body/headers. Only actions already declared in the model are
+        # allowed.
+        #
+        # @param body [String] raw `String`-like body as provided by the transport protocol
+        # @param headers [Hash] raw headers as provided by the transport protocol
+        # @return [Set] set of parsed instances
+        def action_instances(body, _headers = nil)
+          Json::Validator.validate_action_instance! body
+          Set.new [Json::ActionInstance.json(body, model)]
+        end
+
+        # Parses categories from the given body/headers and returns corresponding instances
+        # from the known model.
+        #
+        # @param body [String] raw `String`-like body as provided by the transport protocol
+        # @param headers [Hash] raw headers as provided by the transport protocol
+        # @param expectation [Class] expected class of the returned instance(s)
+        # @return [Set] set of instances
+        def categories(body, _headers = nil, expectation = nil)
+          expectation ||= Occi::Core::Category
+          Json::Validator.validate_model! body
+          Json::Category.json(body, Set.new, false).map { |c| lookup c.identifier, expectation }.to_set
+        end
+
+        # :nodoc:
+        def validate_entities!(body)
+          found = nil
+
+          %i[link resource entity-collection].each do |type|
+            begin
+              Json::Validator.validate! body, type
+              found = type
+            rescue
+              logger.debug "#{self.class}: Body isn't #{type}"
+            end
+          end
+          raise Occi::Core::Errors::ParsingError, "#{self.class} -> No entity sub-type instance found" unless found
+
+          found
+        end
+        private :validate_entities!
+
+        class << self
+          # Extracts categories from body and headers. For details, see `Occi::Core::Parsers::Json::Category`.
+          #
+          # @param body [String] raw `String`-like body as provided by the transport protocol
+          # @param headers [Hash] raw headers as provided by the transport protocol
+          # @param media_type [String] media type string as provided by the transport protocol
+          # @param model [Occi::Core::Model] `Model`-like instance to be populated (may contain existing categories)
+          # @return [Occi::Core::Model] model instance filled with parsed categories
+          def model(body, _headers, media_type, model)
+            unless media_types.include?(media_type)
+              raise Occi::Core::Errors::ParsingError,
+                    "#{self} -> model cannot be parsed from #{media_type.inspect}"
+            end
+            Json::Validator.validate_model! body
+            Json::Category.json body, model
+            model
+          end
+
+          # Extracts URI-like locations from body and headers. For details, see `Occi::Core::Parsers::Json::Location`.
+          #
+          # @param body [String] raw `String`-like body as provided by the transport protocol
+          # @param headers [Hash] raw headers as provided by the transport protocol
+          # @param media_type [String] media type string as provided by the transport protocol
+          # @return [Array] list of extracted URIs
+          def locations(body, _headers, media_type)
+            unless media_types.include?(media_type)
+              raise Occi::Core::Errors::ParsingError,
+                    "#{self} -> locations cannot be parsed from #{media_type.inspect}"
+            end
+            Json::Validator.validate_locations! body
+            handle(Occi::Core::Errors::ParsingError) { JSON.parse(body).map { |i| URI.parse(i) } }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/occi/core/parsers/text/category.rb

@@ -0,0 +1,183 @@
+module Occi
+  module Core
+    module Parsers
+      module Text
+        # Static parsing class responsible for extracting categories from plain text.
+        # Class supports 'text/plain' via `plain`. No other formats are supported.
+        #
+        # @author Boris Parak <parak@cesnet.cz>
+        class Category
+          include Yell::Loggable
+          extend Helpers::ParserDereferencer
+
+          # Regexp constants
+          CATEGORY_REGEXP  = /#{Constants::REGEXP_CATEGORY}/
+          ATTRIBUTE_REGEXP = /^#{Constants::REGEXP_ATTRIBUTE_DEF}$/
+
+          # Hash constants for ParserDereferencer
+          PARENT_KEY  = :rel
+          APPLIES_KEY = :rel
+          DEPENDS_KEY = :rel
+
+          class << self
+            # Parses category lines into instances of subtypes of `Occi::Core::Category`. Internal references
+            # between objects are converted from strings to actual objects. Categories provided in the model
+            # will be reused but have to be declared in the parsed model as well. This mechanism can be used to
+            # introduce properly typed attribute definitions to 'plain/text'-based models.
+            #
+            # @param lines [Array] list of single-category lines
+            # @param model [Occi::Core::Model] model with existing categories
+            # @return [Occi::Core::Model] model with all known category instances
+            def plain(lines, model)
+              raw_categories = []
+
+              lines.each do |line|
+                raw_categories << plain_category(line)
+                model << construct_instance(raw_categories.last)
+              end
+              dereference_identifiers! model.categories, raw_categories
+
+              model
+            end
+
+            # Parses a single-category line into a raw category hash containing all the necessary
+            # information for creating an instance.
+            #
+            # @param line [String] single-category line containing the definition
+            # @param full [TrueClass, FalseClass] parse full definition, defaults to `true`
+            # @return [Hash] raw category hash for further processing
+            def plain_category(line, full = true)
+              matched = line.match(CATEGORY_REGEXP)
+              unless matched
+                raise Occi::Core::Errors::ParsingError,
+                      "#{self} -> #{line.inspect} does not match expectations for Category"
+              end
+
+              cat = matchdata_to_hash(matched)
+              return cat unless full
+
+              cat[:attributes] = plain_attributes(cat[:attributes]) if cat[:attributes]
+              cat[:rel] = plain_identifiers(cat[:rel]) if cat[:rel]
+              cat[:actions] = plain_identifiers(cat[:actions]) if cat[:actions]
+
+              cat
+            end
+
+            # Parses a multi-attribute line into a multi-attribute hash. The resulting hash has
+            # attribute names pointing to attribute definitions.
+            #
+            # @example
+            #    plain_attributes 'occi.core.id{required immutable} occi.storage.size' # => {...}
+            #
+            # @param line [String] multi-attribute line from a category definition
+            # @return [Hash] hash with attribute names pointing to attribute definitions
+            def plain_attributes(line)
+              # TODO: find a better approach to fixing split
+              line.gsub!(/\{(immutable|required)\s+(required|immutable)\}/, '{\1_\2}')
+
+              attributes = {}
+              line.split.each { |attribute| attributes.merge! plain_attribute(attribute) }
+
+              attributes
+            end
+
+            # Parses an attribute line into an attribute hash. The resulting hash has
+            # the attribute name pointing to the attribute definition.
+            #
+            # @example
+            #    plain_attribute 'occi.core.id{required immutable}' # => {...}
+            #
+            # @param line [String] single-attribute line from a category definition
+            # @return [Hash] hash with attribute name pointing to attribute definition
+            def plain_attribute(line)
+              # TODO: find a better approach to fixing split
+              line.gsub!(/\{(immutable|required)_(required|immutable)\}/, '{\1 \2}')
+
+              matched = line.match(ATTRIBUTE_REGEXP)
+              unless matched && matched[1]
+                raise Occi::Core::Errors::ParsingError,
+                      "#{self} -> #{line.inspect} does not match expectations for Attribute"
+              end
+
+              { matched[1] => plain_attribute_definition(matched[-2]) }
+            end
+
+            # Parses a line with attribute definitions into an `Occi::Core::AttributeDefinition` instance.
+            #
+            # @example
+            #    plain_attribute_definition '{required immutable}'
+            #       # => Occi::Core::AttributeDefinition
+            #
+            # @param line [String] line with plain text attribute definition(s)
+            # @return [Occi::Core::AttributeDefinition] constructed instance
+            def plain_attribute_definition(line)
+              attr_def = Occi::Core::AttributeDefinition.new
+              return attr_def if line.blank?
+
+              attr_def.required! if line.include?('required')
+              attr_def.immutable! if line.include?('immutable')
+
+              attr_def
+            end
+
+            # Separates category identifiers from a single-line notation to an
+            # array.
+            #
+            # @example
+            #    plain_identifiers 'http://l/b/c#a http://a/a/b#r' # => [...]
+            #
+            # @param line [String] line with space-separated category identifiers
+            # @return [Array] list of separated category identifiers
+            def plain_identifiers(line)
+              line.split.map(&:strip)
+            end
+
+            # Constructs an instance of `parsed[:class]` with given arguments.
+            # All classes must be located in the `Occi::Core` namespace.
+            #
+            # @param parsed [Hash] arguments for instance construction
+            # @return [Object] constructed instance
+            def construct_instance(parsed)
+              all = {
+                term: parsed[:term], schema: parsed[:scheme], title: parsed[:title],
+                attributes: parsed[:attributes] ? parsed[:attributes] : {}
+              }
+
+              klass = parsed[:class].capitalize
+              klass = Occi::Core.const_get(klass)
+              all[:location] = parsed[:location] if klass.instance_methods.include?(:location)
+
+              klass.new(all)
+            end
+
+            # @param mixin [Occi::Core::Mixin] mixin instance needing applicability dereferencing
+            # @param derefd [Array] list of all available category instances
+            # @param parsed_rel [Array] textual representations of needed applicability targets
+            def lookup_applies_references!(mixin, derefd, parsed_rel)
+              return if parsed_rel.blank? || parsed_rel.count == 1 # only depends here
+              parsed_rel.drop(1).each { |kind| mixin.applies << first_or_die(derefd, kind) }
+            end
+
+            # @param mixin [Occi::Core::Mixin] mixin instance needing dependency dereferencing
+            # @param derefd [Array] list of all available category instances
+            # @param parsed_rel [Array] textual representations of needed dependencies
+            def lookup_depends_references!(mixin, derefd, parsed_rel)
+              return if parsed_rel.blank?
+              mixin.depends << first_or_die(derefd, parsed_rel.first)
+            end
+
+            # @param md [MatchData] `MatchData` instance to be converted
+            # @return [Hash] converted hash
+            def matchdata_to_hash(md)
+              hash = {}
+              md.names.each { |group| md[group] && hash[group.to_sym] = md[group] }
+              hash
+            end
+
+            private :lookup_applies_references!, :lookup_depends_references!
+          end
+        end
+      end
+    end
+  end
+end

data/lib/occi/core/parsers/text/constants.rb

@@ -0,0 +1,89 @@
+module Occi
+  module Core
+    module Parsers
+      module Text
+        module Constants
+          # Base regular expressions
+          REGEXP_QUOTED_STRING = /([^"\\]|\\.)*/
+          REGEXP_LOALPHA = /[a-z]/
+          REGEXP_ALPHA = /[a-zA-Z]/
+          REGEXP_DIGIT = /[0-9]/
+          REGEXP_INT = /#{REGEXP_DIGIT}+/
+          REGEXP_FLOAT = /#{REGEXP_INT}\.#{REGEXP_INT}/
+          REGEXP_NUMBER = /#{REGEXP_FLOAT}|#{REGEXP_INT}/
+          REGEXP_BOOL = /\b(?<!\|)true(?!\|)\b|\b(?<!\|)false(?!\|)\b/
+
+          # Regular expressions for OCCI
+          REGEXP_TERM = /(#{REGEXP_ALPHA}|#{REGEXP_DIGIT})(#{REGEXP_ALPHA}|#{REGEXP_DIGIT}|-|_)*/ # Compatibility with terms starting with a number
+          REGEXP_TERM_STRICT = /#{REGEXP_LOALPHA}(#{REGEXP_LOALPHA}|#{REGEXP_DIGIT}|-|_)*/
+          REGEXP_SCHEME = /#{URI::ABS_URI_REF}#/
+          REGEXP_TYPE_IDENTIFIER = /#{REGEXP_SCHEME}#{REGEXP_TERM}/
+          REGEXP_TYPE_IDENTIFIER_STRICT = /#{REGEXP_SCHEME}#{REGEXP_TERM_STRICT}/
+          REGEXP_CLASS = /\b(?<!\|)action(?!\|)\b|\b(?<!\|)mixin(?!\|)\b|\b(?<!\|)kind(?!\|)\b/
+          REGEXP_TYPE_IDENTIFIER_LIST = /#{REGEXP_TYPE_IDENTIFIER}(\s+#{REGEXP_TYPE_IDENTIFIER})*/
+          REGEXP_TYPE_IDENTIFIER_LIST_STRICT = /#{REGEXP_TYPE_IDENTIFIER_STRICT}(\s+#{REGEXP_TYPE_IDENTIFIER_STRICT})*/
+
+          REGEXP_ATTR_COMPONENT = /#{REGEXP_LOALPHA}(#{REGEXP_LOALPHA}|#{REGEXP_DIGIT}|-|_)*/
+          REGEXP_ATTRIBUTE_NAME = /#{REGEXP_ATTR_COMPONENT}(\.#{REGEXP_ATTR_COMPONENT})*/
+          REGEXP_ATTRIBUTE_PROPERTY = /\b(?<!\|)immutable(?!\|)\b|\b(?<!\|)required(?!\|)\b/
+          REGEXP_ATTRIBUTE_DEF = /(#{REGEXP_ATTRIBUTE_NAME})(\{#{REGEXP_ATTRIBUTE_PROPERTY}(\s+#{REGEXP_ATTRIBUTE_PROPERTY})*\})?/
+          REGEXP_ATTRIBUTE_LIST = /#{REGEXP_ATTRIBUTE_DEF}(\s+#{REGEXP_ATTRIBUTE_DEF})*/
+          REGEXP_ATTRIBUTE_REPR = /#{REGEXP_ATTRIBUTE_NAME}=("#{REGEXP_QUOTED_STRING}"|#{REGEXP_NUMBER}|#{REGEXP_BOOL})/
+
+          REGEXP_ACTION = /#{REGEXP_TYPE_IDENTIFIER}/
+          REGEXP_ACTION_STRICT = /#{REGEXP_TYPE_IDENTIFIER_STRICT}/
+          REGEXP_ACTION_LIST = /#{REGEXP_ACTION}(\s+#{REGEXP_ACTION})*/
+          REGEXP_ACTION_LIST_STRICT = /#{REGEXP_ACTION_STRICT}(\s+#{REGEXP_ACTION_STRICT})*/
+
+          REGEXP_RESOURCE_TYPE = /#{REGEXP_TYPE_IDENTIFIER}(\s+#{REGEXP_TYPE_IDENTIFIER})*/
+          REGEXP_RESOURCE_TYPE_STRICT = /#{REGEXP_TYPE_IDENTIFIER_STRICT}(\s+#{REGEXP_TYPE_IDENTIFIER_STRICT})*/
+          REGEXP_LINK_INSTANCE = /#{URI::URI_REF}/
+          REGEXP_LINK_TYPE = /#{REGEXP_TYPE_IDENTIFIER}(\s+#{REGEXP_TYPE_IDENTIFIER})*/
+          REGEXP_LINK_TYPE_STRICT = /#{REGEXP_TYPE_IDENTIFIER_STRICT}(\s+#{REGEXP_TYPE_IDENTIFIER_STRICT})*/
+
+          # Regular expression for OCCI Categories
+          REGEXP_CATEGORY = "^Category:\\s*(?<term>#{REGEXP_TERM})" << # term (mandatory)
+                            ";\\s*scheme=\"(?<scheme>#{REGEXP_SCHEME})#{REGEXP_TERM}?\"" << # scheme (mandatory)
+                            ";\\s*class=\"?(?<class>#{REGEXP_CLASS})\"?" << # class (mandatory)
+                            "(;\\s*title=\"(?<title>#{REGEXP_QUOTED_STRING})\")?" << # title (optional)
+                            "(;\\s*rel=\"(?<rel>#{REGEXP_TYPE_IDENTIFIER_LIST})\")?" << # rel (optional)
+                            "(;\\s*location=\"(?<location>#{URI::URI_REF})\")?" << # location (optional)
+                            "(;\\s*attributes=\"(?<attributes>#{REGEXP_ATTRIBUTE_LIST})\")?" << # attributes (optional)
+                            "(;\\s*actions=\"(?<actions>#{REGEXP_ACTION_LIST})\")?" << # actions (optional)
+                            ';?$' # additional semicolon at the end (not specified, for interoperability)
+          REGEXP_CATEGORY_STRICT = "^Category:\\s*(?<term>#{REGEXP_TERM_STRICT})" << # term (mandatory)
+                                   ";\\s*scheme=\"(?<scheme>#{REGEXP_SCHEME})\"" << # scheme (mandatory)
+                                   ";\\s*class=\"(?<class>#{REGEXP_CLASS})\"" << # class (mandatory)
+                                   "(;\\s*title=\"(?<title>#{REGEXP_QUOTED_STRING})\")?" << # title (optional)
+                                   "(;\\s*rel=\"(?<rel>#{REGEXP_TYPE_IDENTIFIER_LIST_STRICT})\")?" << # rel (optional)
+                                   "(;\\s*location=\"(?<location>#{URI::URI_REF})\")?" << # location (optional)
+                                   "(;\\s*attributes=\"(?<attributes>#{REGEXP_ATTRIBUTE_LIST})\")?" << # attributes (optional)
+                                   "(;\\s*actions=\"(?<actions>#{REGEXP_ACTION_LIST_STRICT})\")?" << # actions (optional)
+                                   ';?$' # additional semicolon at the end (not specified, for interoperability)
+
+          # Regular expression for OCCI Link Instance References
+          REGEXP_LINK = "^Link:\\s*\\<(?<uri>#{URI::URI_REF})\\>" << # uri (mandatory)
+                        ";\\s*rel=\"(?<rel>#{REGEXP_RESOURCE_TYPE})\"" << # rel (mandatory)
+                        "(;\\s*self=\"(?<self>#{REGEXP_LINK_INSTANCE})\")?" << # self (optional)
+                        "(;\\s*category=\"(?<category>(;?\\s*(#{REGEXP_LINK_TYPE}))+)\")?" << # category (optional)
+                        "(?<attributes>(;?\\s*(#{REGEXP_ATTRIBUTE_REPR}))*)" << # attributes (optional)
+                        ';?$' # additional semicolon at the end (not specified, for interoperability)
+          REGEXP_LINK_STRICT = "^Link:\\s*\\<(?<uri>#{URI::URI_REF})\\>" << # uri (mandatory)
+                               ";\\s*rel=\"(?<rel>#{REGEXP_RESOURCE_TYPE_STRICT})\"" << # rel (mandatory)
+                               "(;\\s*self=\"(?<self>#{REGEXP_LINK_INSTANCE})\")?" << # self (optional)
+                               "(;\\s*category=\"(?<category>(;?\\s*(#{REGEXP_LINK_TYPE_STRICT}))+)\")?" << # category (optional)
+                               "(?<attributes>(;\\s*(#{REGEXP_ATTRIBUTE_REPR}))*)" << # attributes (optional)
+                               ';?$' # additional semicolon at the end (not specified, for interoperability)
+
+          # Regular expression for OCCI Entity Attributes
+          REGEXP_ATTRIBUTE = "^X-OCCI-Attribute:\\s*(?<name>#{REGEXP_ATTRIBUTE_NAME})=(\"(?<string>#{REGEXP_QUOTED_STRING})\"|(?<number>#{REGEXP_NUMBER})|(?<bool>#{REGEXP_BOOL}))" \
+                             ';?$'.freeze # additional semicolon at the end (not specified, for interoperability)
+
+          # Regular expression for OCCI Location
+          REGEXP_LOCATION = "^X-OCCI-Location:\\s*(?<location>#{URI::URI_REF})" \
+                            ';?$'.freeze # additional semicolon at the end (not specified, for interoperability)
+        end
+      end
+    end
+  end
+end

data/lib/occi/core/parsers/text/entity.rb

@@ -0,0 +1,257 @@
+module Occi
+  module Core
+    module Parsers
+      module Text
+        # Static parsing class responsible for extracting entities from plain text.
+        # Class supports 'text/plain' via `plain`. No other formats are supported.
+        #
+        # @attr model [Occi::Core::Model, Occi::Infrastructure::Model] model to use as a primary reference point
+        #
+        # @author Boris Parak <parak@cesnet.cz>
+        class Entity
+          include Yell::Loggable
+          include Helpers::ArgumentValidator
+          include Helpers::ErrorHandler
+
+          # Regexp constants
+          ATTRIBUTE_REGEXP = /#{Constants::REGEXP_ATTRIBUTE}/
+          LINK_REGEXP      = /#{Constants::REGEXP_LINK}/
+
+          # Typecasting lambdas
+          DEFAULT_LAMBDA  = ->(val) { raise "#{self} -> Cannot typecast #{val.inspect} to an unknown type" }
+
+          FLOAT_LAMBDA    = ->(val) { val.to_f }
+          JSON_LAMBDA     = ->(val) { JSON.parse(val) }
+
+          TYPECASTER_HASH = {
+            IPAddr  => ->(val) { IPAddr.new val },
+            URI     => ->(val) { URI.parse val },
+            String  => ->(val) { val },
+            Float   => FLOAT_LAMBDA,
+            Numeric => FLOAT_LAMBDA,
+            Integer => ->(val) { val.to_i },
+            Boolean => ->(val) { val.casecmp('true') || val.casecmp('yes') },
+            Array   => JSON_LAMBDA,
+            Hash    => JSON_LAMBDA
+          }.freeze
+
+          attr_reader :model
+
+          # Constructs an instance of the entity parser. Only entities (their kinds) defined by the model are allowed.
+          #
+          # @param args [Hash] constructor arguments in a Hash
+          # @option args [Occi::Core::Model] :model model to use as a primary reference point
+          def initialize(args = {})
+            pre_initialize(args)
+            default_args! args
+
+            @model = args.fetch(:model)
+
+            post_initialize(args)
+          end
+
+          # Builds an entity instances from the lines provided as input.
+          #
+          # @param lines [Array] list of lines containing a single entity rendering
+          # @return [Occi::Core::Entity] constructed instance
+          def plain(lines)
+            cats = plain_categories(lines)
+            kind = cats.detect { |c| c.is_a?(Occi::Core::Kind) }
+            raise Occi::Core::Errors::ParsingError, "#{self.class} -> Entity does not specify its kind" unless kind
+
+            entity = @_ib.build(kind.identifier)
+            cats.each { |cat| cat.is_a?(Occi::Core::Mixin) && entity << cat }
+
+            plain_attributes! lines, entity.attributes
+            plain_links! lines, entity
+
+            entity
+          end
+
+          # Parses categories from entity lines. Every category is looked up in the model.
+          #
+          # @param lines [Array] list of lines containing a single entity rendering
+          # @return [Array] list of identified category instances
+          def plain_categories(lines)
+            lines.map do |line|
+              next unless line.start_with?(TextParser::CATEGORY_KEYS.first)
+              cat = Category.plain_category(line, false)
+              handle(Occi::Core::Errors::ParsingError) { model.find_by_identifier!("#{cat[:scheme]}#{cat[:term]}") }
+            end.compact
+          end
+
+          # Parses attributes from entity lines. Every attribute value is typed according to the attribute
+          # specification provided by the model (in the defined kind).
+          #
+          # @param lines [Array] list of lines containing a single entity rendering
+          # @param attributes [Hash] defined attributes
+          # @return [Hash] parsed and typed attributes
+          def plain_attributes!(lines, attributes)
+            lines.each do |line|
+              next unless line.start_with?(TextParser::ATTRIBUTE_KEYS.first)
+              name, value = raw_attribute(line)
+              unless attributes[name]
+                raise Occi::Core::Errors::ParsingError,
+                      "#{self.class} -> attribute #{name.inspect} is not allowed for this entity"
+              end
+              attributes[name].value = handle(Occi::Core::Errors::ParsingError) do
+                typecast value, attributes[name].attribute_definition.type
+              end
+            end
+            attributes
+          end
+
+          # Parses a single attribute line to identify name and value.
+          #
+          # @param line [String] line containing a single entity attribute
+          # @return [Array] two-element array with name and value of the attribute
+          def raw_attribute(line)
+            matched = line.match(ATTRIBUTE_REGEXP)
+            unless matched
+              raise Occi::Core::Errors::ParsingError,
+                    "#{self.class} -> #{line.inspect} does not match expectations for Attribute"
+            end
+            [matched[:name], matched[:string] || matched[:number] || matched[:bool]]
+          end
+
+          # Parses links attached to the entity instance. This includes both action "links" and ordinary
+          # OCCI links between resources.
+          #
+          # @param lines [Array] list of lines containing a single entity rendering
+          # @param entity [Occi::Core::Entity] partially constructed entity instance to be updated
+          # @return [Occi::Core::Entity] updated entity instance
+          def plain_links!(lines, entity)
+            lines.each do |line|
+              next unless line.start_with?(TextParser::LINK_KEYS.first)
+              matched = line.match(LINK_REGEXP)
+              unless matched
+                raise Occi::Core::Errors::ParsingError,
+                      "#{self.class} -> #{line.inspect} does not match expectations for Link"
+              end
+              plain_link! matched, entity
+            end
+            entity
+          end
+
+          # Constructs a single link instance. This includes both action "links" and ordinary OCCI links.
+          #
+          # @param md [MatchData] Hash-like structure with matched parts of the link
+          # @param entity [Occi::Core::Entity] partially constructed entity instance to be updated
+          def plain_link!(md, entity)
+            md[:uri].include?('?action=') ? plain_action!(md, entity) : plain_oglink!(md, entity)
+          end
+
+          # Looks up the action mentioned in the given action "link" and assigns it to the given partially
+          # constructed entity instance.
+          #
+          # @param md [MatchData] Hash-like structure with matched parts of the link
+          # @param entity [Occi::Core::Entity] partially constructed entity instance to be updated
+          def plain_action!(md, entity)
+            entity << handle(Occi::Core::Errors::ParsingError) { model.find_by_identifier!(md[:rel]) }
+          end
+
+          # Constructs a single link instance. Supports only ordinary OCCI links between resources.
+          #
+          # @param md [MatchData] Hash-like structure with matched parts of the link
+          # @param entity [Occi::Core::Entity] partially constructed entity instance to be updated
+          def plain_oglink!(md, entity)
+            unless entity.respond_to?(:links)
+              raise Occi::Core::Errors::ParsingError,
+                    "#{self.class} -> Cannot assign links to entity #{entity.id} which does not support them"
+            end
+
+            link = plain_oglink_instance(md)
+            link.location = handle(Occi::Core::Errors::ParsingError) { URI.parse md[:self] }
+            entity.links << link
+
+            plain_oglink_attributes! md, link
+
+            entity
+          end
+
+          # Constructs a single link instance based on the provided data. The returned instance does include contain
+          # action instance attributes!
+          #
+          # @param md [MatchData] Hash-like structure with matched parts of the link
+          # @return [Occi::Core::Link] constructed link instance
+          def plain_oglink_instance(md)
+            if md[:category].blank? || md[:self].blank?
+              raise Occi::Core::Errors::ParsingError,
+                    "#{self.class} -> Link #{md[:uri].inspect} is missing type and location information"
+            end
+
+            categories = md[:category].split
+            target_kind = handle(Occi::Core::Errors::ParsingError) { model.find_by_identifier!(md[:rel]) }
+            link = @_ib.build(categories.shift, target_kind: target_kind)
+            categories.each do |mxn|
+              link << handle(Occi::Core::Errors::ParsingError) { model.find_by_identifier!(mxn) }
+            end
+
+            link
+          end
+
+          # Attaches attributes to an existing link instance.
+          #
+          # @param md [MatchData] Hash-like structure with matched parts of the link
+          # @param link [Occi::Core::Link] partially constructed link instance to be updated
+          def plain_oglink_attributes!(md, link)
+            if md[:attributes].blank?
+              raise Occi::Core::Errors::ParsingError,
+                    "#{self.class} -> Link #{link.id} is missing attribute information"
+            end
+
+            line = md[:attributes].strip.gsub(/^;\s*/, '')
+            attrs = line.split(';').map { |attrb| "#{TextParser::ATTRIBUTE_KEYS.first}: #{attrb}" }
+            plain_attributes! attrs, link.attributes
+
+            link
+          end
+
+          # Typecasts attribute values from String to the desired type.
+          #
+          # @param value [String] attribute value
+          # @param type [Class,Module] desired attribute type
+          # @return [Object] typecasted value
+          def typecast(value, type)
+            if value.nil? || type.nil?
+              raise Occi::Core::Errors::ParsingError,
+                    "#{self.class} -> Cannot typecast (un)set value to (un)set type"
+            end
+
+            self.class.typecaster[type].call(value)
+          end
+
+          class << self
+            # Constructs a map pointing from expected attribute types to conversion lambdas.
+            #
+            # @return [Hash] typecaster hash with conversion lambdas
+            def typecaster
+              Hash.new(DEFAULT_LAMBDA).merge(TYPECASTER_HASH)
+            end
+          end
+
+          protected
+
+          # :nodoc:
+          def sufficient_args!(args)
+            return if args[:model]
+            raise Occi::Core::Errors::MandatoryArgumentError, "Model is a mandatory argument for #{self.class}"
+          end
+
+          # :nodoc:
+          def defaults
+            { model: nil }
+          end
+
+          # :nodoc:
+          def pre_initialize(args); end
+
+          # :nodoc:
+          def post_initialize(_args)
+            @_ib = model.instance_builder
+          end
+        end
+      end
+    end
+  end
+end