occi-core 5.0.0.alpha.4 → 5.0.0.beta.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 196f824b580d6a90fe2da14cbf85b99deb088d93
-  data.tar.gz: 8b06f630a141c702742c019529bf11184e8ce87f
+  metadata.gz: bac82f913d97840096bf9d40d0e492fec5ed3b8f
+  data.tar.gz: dd0af74945ae6464ddf58e91cb4fa220d3409968
 SHA512:
-  metadata.gz: db0db57a71621cf8beb45e2682659831a8aff23356efbdf26d6b1160f4a36d8e69ef9ecb94b55819d7584825dbc74034f6c1a155bf62d374c98722602a8d2f52
-  data.tar.gz: 93ef6536c47a7d0b3225f0ffb5280eaacc2b6b5611c4d902bcb5374bbf0cf162abfdbee0fdb58e35d0c914a514786a36ee8719ecd881c953afff81cc0b60e070
+  metadata.gz: 2fa653867bd073489c1b8f584125c6b5eff7d8675aad1298d0f5b1cef057d6327a076a7d938a70a0d1d1eb5a124d3258ccc57b8412c93fd6fe6a9cd150eb3a39
+  data.tar.gz: b8b8ce1728507099d3b932e4abf9388f53256a0692628868c96bb98ab16998ba2d57d74cf3ffb68fe1470e8074980d2f83b790a37e78cc2685b1bae42d9dc3c6

data/.rubocop.yml

@@ -55,6 +55,10 @@ Style/FileName:
   Exclude:
   - 'lib/occi/infrastructure-ext.rb'
 
+Style/YodaCondition:
+  Exclude:
+  - 'lib/occi/core/helpers/parser_dereferencer.rb'
+
 RSpec/MultipleExpectations:
   Max: 5
 

data/lib/occi/core/helpers/argument_validator.rb

@@ -8,7 +8,7 @@ module Occi
       module ArgumentValidator
         # :nodoc:
         def default_args!(args)
-          logger.debug "#{self.class}: Merging given args #{args.inspect} with defaults #{defaults.inspect}"
+          logger.debug "Merging #{self.class} args #{args.inspect} with defaults #{defaults.inspect}"
           args.merge!(defaults) { |_, oldval, _| oldval }
           sufficient_args!(args)
         end

data/lib/occi/core/helpers/hash_dereferencer.rb

@@ -128,6 +128,7 @@ module Occi
         # @param model [Occi::Core::Model] model instance for dereferencing (category look-up)
         # @return [Occi::Core::Category] instance located in the model
         def dereference_via_model(identifier, model)
+          logger.debug "Dereferencing #{identifier.inspect} by look-up in model"
           model.find_by_identifier!(identifier)
         end
 
@@ -138,6 +139,7 @@ module Occi
         # @param hash [Hash] hash with known attribute definitions for dereferencing
         # @return [Occi::Core::AttributeDefinition] definition located in the hash
         def dereference_via_hash(identifier, hash)
+          logger.debug "Dereferencing #{identifier.inspect} by look-up in hash"
           raise "Attribute definition #{identifier.inspect} not found in the hash" unless hash[identifier]
           hash[identifier]
         end

data/lib/occi/core/helpers/identifier_validator.rb

@@ -25,7 +25,7 @@ module Occi
           begin
             valid_term! term
           rescue Occi::Core::Errors::CategoryValidationError => ex
-            logger.warn "#{self}: Term validation failed with #{ex.message}" if respond_to?(:logger)
+            logger.warn "Term validation for #{self} failed with #{ex.message}" if respond_to?(:logger)
             return false
           end
 
@@ -58,7 +58,7 @@ module Occi
           begin
             valid_schema! schema
           rescue URI::InvalidURIError, Occi::Core::Errors::CategoryValidationError => ex
-            logger.warn "#{self}: Schema validation failed with #{ex.message}" if respond_to?(:logger)
+            logger.warn "Schema validation for #{self} failed with #{ex.message}" if respond_to?(:logger)
             return false
           end
 
@@ -96,7 +96,7 @@ module Occi
           begin
             valid_identifier! identifier
           rescue URI::InvalidURIError, Occi::Core::Errors::CategoryValidationError => ex
-            logger.warn "#{self}: Identifier validation failed with #{ex.message}" if respond_to?(:logger)
+            logger.warn "Identifier validation for #{self} failed with #{ex.message}" if respond_to?(:logger)
             return false
           end
 

data/lib/occi/core/helpers/instance_attribute_resetter.rb

@@ -53,7 +53,7 @@ module Occi
           name_cache = attribute_names
           attributes.keep_if do |key, value|
             defined = name_cache.include?(key) && value && value.attribute_definition
-            logger.debug "#{self.class}: Removing undefined attribute #{key.inspect}" unless defined
+            logger.debug "Removing undefined attribute #{key.inspect} on #{self.class}" unless defined
             defined
           end
         end
@@ -122,10 +122,10 @@ module Occi
         # @param force [TrueClass, FalseClass] forcibly change attribute value to default
         def reset_attribute(name, definition, force)
           if attributes[name]
-            logger.debug "#{self.class}: Setting attribute definition for existing #{name.inspect}"
+            logger.debug "Setting attribute definition for existing #{name.inspect} on #{self.class}"
             attributes[name].attribute_definition = definition
           else
-            logger.debug "#{self.class}: Creating attribute definition for new #{name.inspect}"
+            logger.debug "Creating attribute definition for new #{name.inspect} on #{self.class}"
             attributes[name] = Attribute.new(nil, definition)
           end
 

data/lib/occi/core/helpers/parser_dereferencer.rb

@@ -28,7 +28,7 @@ module Occi
         # @param parsed [Array] list of original parsed category structures
         def lookup_references!(cat, derefd, parsed)
           parsed_cat = parsed.detect { |pcat| "#{pcat[:scheme]}#{pcat[:term]}" == cat.identifier }
-          raise Occi::Core::Errors::ParsingError, "#{self} -> #{cat.identifier} not in the model" unless parsed_cat
+          raise Occi::Core::Errors::ParsingError, "Category #{cat.identifier} not in the model" unless parsed_cat
           lookup_action_references!(cat, derefd, parsed_cat[:actions])
 
           if cat.is_a?(Occi::Core::Mixin)
@@ -44,7 +44,7 @@ module Occi
         # @param derefd [Array] list of all available category instances
         # @param parsed_actions [Array] textual representation of needed actions
         def lookup_action_references!(cat, derefd, parsed_actions)
-          logger.debug "#{self}: Dereferencing actions #{parsed_actions.inspect} for #{cat.identifier.inspect}"
+          logger.debug "Dereferencing actions #{parsed_actions.inspect} for #{cat.identifier.inspect}"
           return if parsed_actions.blank?
           parsed_actions.each { |action| cat.actions << first_or_die(derefd, action) }
         end
@@ -54,11 +54,11 @@ module Occi
         # @param parsed_rel [Array] textual representation of needed parent(s)
         def lookup_parent_references!(kind, derefd, parsed_rel)
           return if parsed_rel.blank? || kind.parent.is_a?(Occi::Core::Kind)
-          logger.debug "#{self}: Dereferencing parent #{parsed_rel.inspect} for #{kind.identifier.inspect}"
+          logger.debug "Dereferencing parent #{parsed_rel.inspect} for #{kind.identifier.inspect}"
           if parsed_rel.is_a?(Enumerable)
             if parsed_rel.count > 1
               raise Occi::Core::Errors::ParsingError,
-                    "#{self} -> Kind #{kind} with multiple parents #{parsed_rel.inspect}"
+                    "Kind #{kind} with multiple parents #{parsed_rel.inspect}"
             end
             parsed_rel = parsed_rel.first
           end
@@ -85,11 +85,11 @@ module Occi
         # @param what [String] identifier of the desired item
         # @return [Object] desired item from `where`
         def first_or_die(where, what)
-          logger.debug "#{self}: Looking for #{what.inspect} in #{where.class}"
+          logger.debug "Looking for #{what.inspect} in #{where.class}"
           found = where.detect { |elm| elm.identifier == what }
           unless found
             raise Occi::Core::Errors::ParsingError,
-                  "#{self} -> Category #{what.to_s.inspect} referenced but not provided"
+                  "Category #{what.to_s.inspect} referenced but not provided"
           end
           found
         end

data/lib/occi/core/helpers/raw_json_parser.rb

@@ -10,7 +10,7 @@ module Occi
         def raw_hash(body)
           JSON.parse body, symbolize_names: true
         rescue => ex
-          raise Occi::Core::Errors::ParsingError, "#{self} -> JSON parsing failed: #{ex.message}"
+          raise Occi::Core::Errors::ParsingError, "JSON parsing failed: #{ex.message}"
         end
       end
     end

data/lib/occi/core/helpers/renderable.rb

@@ -55,7 +55,7 @@ module Occi
         # @param base [Class] class receiving this module
         def self.included(base)
           renderer_factory.formats.each do |format|
-            base.logger.debug "Renderable: Adding support for #{format} to #{base}" if base.respond_to?(:logger)
+            base.logger.debug "Adding support for format #{format} to #{base}" if base.respond_to?(:logger)
             base.send(:define_method, "to_#{format}", proc { render(format) })
           end
         end

data/lib/occi/core/helpers/yaml_summoner.rb

@@ -25,7 +25,7 @@ module Occi
           raise 'This method cannot be invoked on instances' unless is_a? Class
           allowed_classes = respond_to?(:allowed_yaml_classes, true) ? allowed_yaml_classes : []
 
-          logger.debug "#{self}: Loading YAML definition from #{path.inspect}"
+          logger.debug "Loading YAML definition for #{self} from #{path.inspect}"
           object_args = YAML.safe_load(File.read(path), allowed_classes)
           object_args.symbolize_keys!
           object_args.dereference_with!(self, model, attribute_definitions) if needs_dereferencing?

data/lib/occi/core/instance_builder.rb

@@ -42,7 +42,7 @@ module Occi
       # @return [Object] constructed instance
       # @return [NilClass] if such an instance could not be constructed
       def build(identifier, args = {})
-        logger.debug "#{self.class}: Building instance of #{identifier.inspect} with #{args.inspect}"
+        logger.debug "Building instance of #{identifier.inspect} with #{args.inspect}"
         k_args = args_with_kind(identifier, args)
         klass(identifier, parent_klass(k_args[:kind])).new k_args
       end
@@ -93,7 +93,7 @@ module Occi
                 "#{found_klass} is not a sub-type of #{known_ancestor}"
         end
 
-        logger.debug "#{self.class}: Found #{found_klass} for #{identifier.inspect}"
+        logger.debug "Found class #{found_klass} for #{identifier.inspect}"
         found_klass
       end
 
@@ -119,10 +119,10 @@ module Occi
       # @return [Class] located known parent class
       def parent_klass(kind)
         if kind.related? kind_instance(Occi::Core::Constants::RESOURCE_KIND)
-          logger.debug "#{self.class}: Identified #{kind.identifier} as Resource"
+          logger.debug "Identified #{kind.identifier} as Resource"
           Occi::Core::Resource
         elsif kind.related? kind_instance(Occi::Core::Constants::LINK_KIND)
-          logger.debug "#{self.class}: Identified #{kind.identifier} as Link"
+          logger.debug "Identified #{kind.identifier} as Link"
           Occi::Core::Link
         else
           raise Occi::Core::Errors::ModelLookupError,

data/lib/occi/core/model.rb

@@ -242,7 +242,7 @@ module Occi
       #    model = Occi::Core::Model.new
       #    model.load_core!
       def load_core!
-        logger.debug "#{self.class}: Loading Core from Warehouse"
+        logger.debug 'Loading Core definitions from Core::Warehouse'
         Occi::Core::Warehouse.bootstrap! self
       end
 

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

@@ -18,6 +18,10 @@ module Occi
 
         attr_accessor :model, :media_type
 
+        # Shortcuts to interesting methods on logger
+        DELEGATED = %i[debug? info? warn? error? fatal?].freeze
+        delegate(*DELEGATED, to: :logger, prefix: true)
+
         # Constructs an instance of the parser that will use a particular model as the reference for every
         # parsed instance. Only instances allowed by the model will be successfuly parsed. In case of
         # `Occi::Core::Category` instances, only identifiers are parsed and existing instances from the model
@@ -32,6 +36,7 @@ module Occi
 
           @model = args.fetch(:model)
           @media_type = args.fetch(:media_type)
+          logger.debug "Initializing parser for #{media_type.inspect}"
 
           post_initialize(args)
         end
@@ -112,12 +117,16 @@ module Occi
         def lookup(identifier, klass)
           found = handle(Occi::Core::Errors::ParsingError) { model.find_by_identifier!(identifier) }
           unless found.is_a?(klass)
-            raise Occi::Core::Errors::ParsingError, "#{self.class} -> #{identifier.inspect} isn't #{klass}"
+            raise Occi::Core::Errors::ParsingError, "#{identifier.inspect} is not of expected class #{klass}"
           end
           found
         end
 
         class << self
+          # Shortcuts to interesting methods on logger
+          DELEGATED = %i[debug? info? warn? error? fatal?].freeze
+          delegate(*DELEGATED, to: :logger, prefix: true)
+
           # Returns a list of supported media types for this parser.
           #
           # @return [Array] list of supported media types

data/lib/occi/core/parsers/json/action_instance.rb

@@ -12,6 +12,10 @@ module Occi
           extend Helpers::RawJsonParser
 
           class << self
+            # Shortcuts to interesting methods on logger
+            DELEGATED = %i[debug? info? warn? error? fatal?].freeze
+            delegate(*DELEGATED, to: :logger, prefix: true)
+
             # Parses action instances. Internal references between objects are converted from strings
             # to actual objects. Actions have to be declared in the provided model.
             #
@@ -20,12 +24,14 @@ module Occi
             # @return [Occi::Core::ActionInstance] action instance
             def json(body, model)
               parsed = raw_hash(body)
-              ep = Entity.new(model: model)
+              action = handle(Occi::Core::Errors::ParsingError) { model.find_by_identifier! parsed[:action] }
 
-              action = handle(Occi::Core::Errors::ParsingError) { model.find_by_identifier!(parsed[:action]) }
+              logger.debug "Identified #{action.class}[#{action.identifier}]"
               ai = Occi::Core::ActionInstance.new(action: action)
+              ep = Entity.new(model: model)
               ep.set_attributes!(ai.attributes, parsed[:attributes]) if parsed[:attributes]
 
+              logger.debug "Parsed into ActionInstance #{ai.inspect}" if logger_debug?
               ai
             end
           end

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

@@ -27,6 +27,10 @@ module Occi
           DEPENDS_KEY = :depends
 
           class << self
+            # Shortcuts to interesting methods on logger
+            DELEGATED = %i[debug? info? warn? error? fatal?].freeze
+            delegate(*DELEGATED, to: :logger, prefix: true)
+
             # Parses categories 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.
@@ -37,10 +41,12 @@ module Occi
             def json(body, model)
               parsed = raw_hash(body)
               instantiate_hashes! parsed, model
+              logger.debug "Parsed into raw hashes #{parsed.inspect}" if logger_debug?
 
               raw_categories = [parsed[:kinds], parsed[:mixins]].flatten.compact
               dereference_identifiers! model.categories, raw_categories
 
+              logger.debug "Returning (updated) model #{model.inspect}" if logger_debug?
               model
             end
 
@@ -53,15 +59,19 @@ module Occi
 
             # :nodoc:
             def instatiate_hash(raw, klass)
+              logger.debug "Creating #{klass} from #{raw.inspect}" if logger_debug?
+
               obj = klass.new(
                 term: raw[:term], schema: raw[:scheme], title: raw[:title],
                 attributes: attribute_definitions(raw[:attributes])
               )
 
               if obj.respond_to?(:location)
+                logger.debug "Setting location #{raw[:location].inspect}" if logger_debug?
                 obj.location = handle(Occi::Core::Errors::ParsingError) { URI.parse(raw[:location]) }
               end
 
+              logger.debug "Created category #{obj.inspect}" if logger_debug?
               obj
             end
 
@@ -71,9 +81,10 @@ module Occi
 
               attr_defs = {}
               raw.each_pair do |k, v|
+                logger.debug "Creating AttributeDefinition for #{k.inspect} from #{v.inspect}" if logger_debug?
                 def_hsh = typecast(v)
                 unless def_hsh[:type]
-                  raise Occi::Core::Errors::ParsingError, "#{self} -> Attribute #{k.to_s.inspect} has no type"
+                  raise Occi::Core::Errors::ParsingError, "Attribute #{k.to_s.inspect} has no type"
                 end
                 attr_defs[k.to_s] = Occi::Core::AttributeDefinition.new def_hsh
               end
@@ -85,18 +96,23 @@ module Occi
             def typecast(hash)
               hash = hash.clone
               hash[:type] = TYPECASTER_HASH[hash[:type]]
-              hash[:pattern] = handle(Occi::Core::Errors::ParsingError) { Regexp.new(hash[:pattern]) } if hash[:pattern]
+
+              return hash if hash[:pattern].blank?
+              hash[:pattern] = handle(Occi::Core::Errors::ParsingError) { Regexp.new(hash[:pattern]) }
+
               hash
             end
 
             # :nodoc:
             def lookup_applies_references!(mixin, derefd, parsed_rel)
+              logger.debug "Looking up applies from #{parsed_rel.inspect}" if logger_debug?
               return if parsed_rel.blank?
               parsed_rel.each { |kind| mixin.applies << first_or_die(derefd, kind) }
             end
 
             # :nodoc:
             def lookup_depends_references!(mixin, derefd, parsed_rel)
+              logger.debug "Looking up depens from #{parsed_rel.inspect}" if logger_debug?
               return if parsed_rel.blank?
               parsed_rel.each { |mxn| mixin.depends << first_or_die(derefd, mxn) }
             end

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

@@ -14,6 +14,10 @@ module Occi
           include Helpers::ErrorHandler
           extend Helpers::RawJsonParser
 
+          # Shortcuts to interesting methods on logger
+          DELEGATED = %i[debug? info? warn? error? fatal?].freeze
+          delegate(*DELEGATED, to: :logger, prefix: true)
+
           # Constants
           SINGLE_INSTANCE_TYPES = %i[resource link].freeze
           MULTI_INSTANCE_TYPES  = %i[entity-collection].freeze
@@ -46,14 +50,16 @@ module Occi
           # @param type [Symbol] `:resource`, `:link`, or `:'entity-collection'`
           # @return [Array] constructed instances
           def json(body, type)
-            case type
-            when *SINGLE_INSTANCE_TYPES
-              json_single self.class.raw_hash(body)
-            when *MULTI_INSTANCE_TYPES
-              json_collection self.class.raw_hash(body)
-            else
-              raise Occi::Core::Errors::ParserError, "#{self.class} -> #{type.to_s.inspect} is not a valid type"
-            end
+            symbol = case type
+                     when *SINGLE_INSTANCE_TYPES
+                       :json_single
+                     when *MULTI_INSTANCE_TYPES
+                       :json_collection
+                     else
+                       raise Occi::Core::Errors::ParserError, "#{type.inspect} is not a valid type"
+                     end
+
+            send symbol, self.class.raw_hash(body)
           end
 
           # Builds an entity instance from the hash provided as input.
@@ -61,12 +67,14 @@ module Occi
           # @param hash [Hash] Hash body for parsing
           # @return [Array] constructed instances
           def json_single(hash)
+            logger.debug "Converting #{hash.inspect} into a single instance" if logger_debug?
             instance = @_ib.get hash[:kind], mixins: lookup(hash[:mixins]), actions: lookup(hash[:actions])
 
             set_attributes! instance.attributes, hash[:attributes]
             set_links! instance.links, hash[:links] if instance.respond_to?(:links)
             set_target! instance, hash[:target] if instance.respond_to?(:target)
 
+            logger.debug "Created instance #{instance.inspect}" if logger_debug?
             Set.new [instance]
           end
 
@@ -77,10 +85,12 @@ module Occi
           def json_collection(hash)
             all = []
 
+            logger.debug "Converting #{hash.inspect} into multiple instances" if logger_debug?
             all.concat hash[:resources] if hash[:resources]
             all.concat hash[:links] if hash[:links]
             all.map! { |a| json_single(a) }
 
+            logger.debug "Created instances #{all.inspect}" if logger_debug?
             Set.new(all).flatten
           end
 
@@ -96,10 +106,11 @@ module Occi
           def set_attributes!(attributes, hash)
             return if hash.blank?
             hash.each_pair do |name, value|
+              logger.debug "Setting attribute #{name} to #{value.inspect}" if logger_debug?
               attribute = attributes[name.to_s]
               unless attribute
                 raise Occi::Core::Errors::ParsingError,
-                      "#{self.class} -> attribute #{name.to_s.inspect} is not allowed for this entity"
+                      "Attribute #{name.inspect} is not allowed for this entity"
               end
               attribute.value = typecast(value, attribute.attribute_definition.type)
             end
@@ -121,11 +132,11 @@ module Occi
           # :nodoc:
           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"
+              raise Occi::Core::Errors::ParsingError, 'Cannot typecast (un)set value to (un)set type'
             end
             return value unless TYPECASTER_HASH.key?(type)
 
+            logger.debug "Typecasting value #{value.inspect} to #{type}" if logger_debug?
             TYPECASTER_HASH[type].call(value)
           end
 

data/lib/occi/core/parsers/json/validator.rb

@@ -7,12 +7,18 @@ module Occi
         #
         # @author Boris Parak <parak@cesnet.cz>
         class Validator
+          include Yell::Loggable
+
           # Repository constants
           SCHEMA_DIR   = 'validator'.freeze
           SCHEMA_REPO  = File.join(File.expand_path(File.dirname(__FILE__)), SCHEMA_DIR)
           BASE_SCHEMAS = %i[occi-schema].freeze
 
           class << self
+            # Shortcuts to interesting methods on logger
+            DELEGATED = %i[debug? info? warn? error? fatal?].freeze
+            delegate(*DELEGATED, to: :logger, prefix: true)
+
             # Validates given `json` text with the appropriate schema for `type`.
             # This method raises `Occi::Core::Errors::ParsingError` on failure.
             #
@@ -20,10 +26,12 @@ module Occi
             # @param type [Symbol] schema selector
             # @raise [Occi::Core::Errors::ParsingError] on validation failure
             def validate!(json, type)
+              logger.debug "Validating #{json.inspect} as #{type}" if logger_debug?
+
               JSON::Validator.schema_reader = JSON::Schema::Reader.new(accept_uri: false, accept_file: true)
               JSON::Validator.validate!(schema_for(type), json, json: true)
             rescue JSON::Schema::JsonParseError, JSON::Schema::ValidationError => e
-              raise Occi::Core::Errors::ParsingError, "#{self} -> #{e.message}"
+              raise Occi::Core::Errors::ParsingError, e.message
             end
 
             # :nodoc:
@@ -66,7 +74,10 @@ module Occi
               if type.blank? || BASE_SCHEMAS.include?(type)
                 raise Occi::Core::Errors::ParserError, "Schema type #{type.inspect} is not allowed"
               end
-              File.join(SCHEMA_REPO, "#{type}.json")
+              schema_path = File.join(SCHEMA_REPO, "#{type}.json")
+              logger.debug "Found JSON schema for #{type} in #{schema_path}" if logger_debug?
+
+              schema_path
             end
             private :schema_for
           end

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

@@ -34,13 +34,14 @@ module Occi
         # @return [Set] set of instances
         def entities(body, _headers = nil, expectation = nil)
           expectation ||= Occi::Core::Entity
+          logger.debug "Parsing #{expectation}(s) from #{body.inspect}" if logger_debug?
           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}"
+              raise Occi::Core::Errors::ParsingError, "Entity is not of type #{expectation}"
             end
           end
 
@@ -54,6 +55,7 @@ module Occi
         # @param headers [Hash] raw headers as provided by the transport protocol
         # @return [Set] set of parsed instances
         def action_instances(body, _headers = nil)
+          logger.debug "Parsing Occi::Core::ActionInstance(s) from #{body.inspect}" if logger_debug?
           Json::Validator.validate_action_instance! body
           Set.new [Json::ActionInstance.json(body, model)]
         end
@@ -67,6 +69,7 @@ module Occi
         # @return [Set] set of instances
         def categories(body, _headers = nil, expectation = nil)
           expectation ||= Occi::Core::Category
+          logger.debug "Parsing #{expectation}(s) from #{body.inspect}" if logger_debug?
           Json::Validator.validate_category_identifiers! body
 
           cats = Set.new
@@ -81,14 +84,15 @@ module Occi
           found = nil
 
           %i[link resource entity-collection].each do |type|
+            logger.debug "Attempting to validate #{body.inspect} as #{type}" if logger_debug?
             begin
               Json::Validator.validate! body, type
               found = type
             rescue => ex
-              logger.debug "#{self.class}: Body isn't #{type} - #{ex.message}"
+              logger.debug "Moving on, body does not contain valid #{type} - #{ex.message.inspect}"
             end
           end
-          raise Occi::Core::Errors::ParsingError, "#{self.class} -> No entity sub-type instance found" unless found
+          raise Occi::Core::Errors::ParsingError, 'No acceptable entity rendering found' unless found
 
           found
         end
@@ -105,10 +109,13 @@ module Occi
           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}"
+                    "Model cannot be parsed from #{media_type.inspect}"
             end
+            logger.debug "Parsing model from #{media_type.inspect} in #{body.inspect}" if logger_debug?
+
             Json::Validator.validate_model! body
             Json::Category.json body, model
+
             model
           end
 
@@ -120,9 +127,10 @@ module Occi
           # @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}"
+              raise Occi::Core::Errors::ParsingError, "Locations cannot be parsed from #{media_type.inspect}"
             end
+            logger.debug "Parsing locations from #{media_type.inspect} in #{body.inspect}" if logger_debug?
+
             Json::Validator.validate_locations! body
             handle(Occi::Core::Errors::ParsingError) { JSON.parse(body).map { |i| URI.parse(i) } }
           end

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

@@ -20,6 +20,10 @@ module Occi
           DEPENDS_KEY = :rel
 
           class << self
+            # Shortcuts to interesting methods on logger
+            DELEGATED = %i[debug? info? warn? error? fatal?].freeze
+            delegate(*DELEGATED, to: :logger, prefix: true)
+
             # 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
@@ -37,6 +41,7 @@ module Occi
               end
               dereference_identifiers! model.categories, raw_categories
 
+              logger.debug "Returning (updated) model #{model.inspect}" if logger_debug?
               model
             end
 
@@ -47,19 +52,33 @@ module Occi
             # @param full [TrueClass, FalseClass] parse full definition, defaults to `true`
             # @return [Hash] raw category hash for further processing
             def plain_category(line, full = true)
+              logger.debug "Parsing line #{line.inspect}" if logger_debug?
               matched = line.match(CATEGORY_REGEXP)
               unless matched
-                raise Occi::Core::Errors::ParsingError,
-                      "#{self} -> #{line.inspect} does not match expectations for Category"
+                raise Occi::Core::Errors::ParsingError, "#{line.inspect} does not match expectations for Category"
               end
 
               cat = matchdata_to_hash(matched)
-              return cat unless full
+              full ? plain_category_extended(cat) : plain_category_partial(cat)
+            end
 
+            # Cleans up partially parsed hash. Removes all potentially inconsitent or unfinished data structures.
+            #
+            # @param cat [Hash] partially parsed hash
+            # @return [Hash] clean partially parsed hash
+            def plain_category_partial(cat)
+              %i[attributes rel actions].each { |el| cat[el] = nil }
+              cat
+            end
+
+            # Finishes parsing of attributes, actions, and referenced categories.
+            #
+            # @param cat [Hash] partially parsed hash
+            # @return [Hash] fully parsed hash
+            def plain_category_extended(cat)
               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
 
@@ -77,6 +96,7 @@ module Occi
 
               attributes = {}
               line.split.each { |attribute| attributes.merge! plain_attribute(attribute) }
+              logger.debug "Matched attributes as #{attributes.inspect}" if logger_debug?
 
               attributes
             end
@@ -92,11 +112,12 @@ module Occi
             def plain_attribute(line)
               # TODO: find a better approach to fixing split
               line.gsub!(/\{(immutable|required)_(required|immutable)\}/, '{\1 \2}')
+              logger.debug "Parsing attribute line #{line.inspect}" if logger_debug?
 
               matched = line.match(ATTRIBUTE_REGEXP)
               unless matched && matched[1]
                 raise Occi::Core::Errors::ParsingError,
-                      "#{self} -> #{line.inspect} does not match expectations for Attribute"
+                      "#{line.inspect} does not match expectations for Attribute"
               end
 
               { matched[1] => plain_attribute_definition(matched[-2]) }

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

@@ -4,7 +4,7 @@ module Occi
       module Text
         module Constants
           # Base regular expressions
-          REGEXP_QUOTED_STRING = /([^"\\]|\\.)*/
+          REGEXP_QUOTED_STRING = /([^\\"]|\\\\|\\")*/
           REGEXP_LOALPHA = /[a-z]/
           REGEXP_ALPHA = /[a-zA-Z]/
           REGEXP_DIGIT = /[0-9]/

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

@@ -13,6 +13,10 @@ module Occi
           include Helpers::ArgumentValidator
           include Helpers::ErrorHandler
 
+          # Shortcuts to interesting methods on logger
+          DELEGATED = %i[debug? info? warn? error? fatal?].freeze
+          delegate(*DELEGATED, to: :logger, prefix: true)
+
           # Regexp constants
           ATTRIBUTE_REGEXP = /#{Constants::REGEXP_ATTRIBUTE}/
           LINK_REGEXP      = /#{Constants::REGEXP_LINK}/
@@ -57,7 +61,8 @@ module Occi
           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
+            raise Occi::Core::Errors::ParsingError, 'Entity does not specify its kind' unless kind
+            logger.debug "Identified entity kind #{kind.inspect}" if logger_debug?
 
             entity = @_ib.build(kind.identifier)
             cats.each { |cat| cat.is_a?(Occi::Core::Mixin) && entity << cat }
@@ -65,6 +70,7 @@ module Occi
             plain_attributes! lines, entity.attributes
             plain_links! lines, entity
 
+            logger.debug "Created instance #{entity.inspect}" if logger_debug?
             entity
           end
 
@@ -73,11 +79,12 @@ module Occi
           # @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|
+            categories = 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
+            categories.compact
           end
 
           # Parses attributes from entity lines. Every attribute value is typed according to the attribute
@@ -89,15 +96,18 @@ module Occi
           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"
+                      "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
 
@@ -106,10 +116,10 @@ module Occi
           # @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)
+            logger.debug "Parsing attribute line #{line.inspect}" if logger_debug?
             matched = line.match(ATTRIBUTE_REGEXP)
             unless matched
-              raise Occi::Core::Errors::ParsingError,
-                    "#{self.class} -> #{line.inspect} does not match expectations for Attribute"
+              raise Occi::Core::Errors::ParsingError, "#{line.inspect} does not match expectations for Attribute"
             end
             [matched[:name], matched[:string] || matched[:number] || matched[:bool]]
           end
@@ -123,13 +133,16 @@ module Occi
           def plain_links!(lines, entity)
             lines.each do |line|
               next unless line.start_with?(TextParser::LINK_KEYS.first)
+              logger.debug "Parsing link line #{line.inspect}" if logger_debug?
+
               matched = line.match(LINK_REGEXP)
               unless matched
-                raise Occi::Core::Errors::ParsingError,
-                      "#{self.class} -> #{line.inspect} does not match expectations for Link"
+                raise Occi::Core::Errors::ParsingError, "#{line.inspect} does not match expectations for Link"
               end
+
               plain_link! matched, entity
             end
+
             entity
           end
 
@@ -157,7 +170,7 @@ module Occi
           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"
+                    "Cannot assign links to entity #{entity.id} which does not support them"
             end
 
             link = plain_oglink_instance(md)
@@ -169,24 +182,25 @@ module Occi
             entity
           end
 
-          # Constructs a single link instance based on the provided data. The returned instance does include contain
+          # Constructs a single link instance based on the provided data. The returned instance does include
           # 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"
+              raise Occi::Core::Errors::ParsingError, "Link #{md[:uri].inspect} 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|
+              logger.debug "Adding mixin #{mxn.inspect} to link instance" if logger_debug?
               link << handle(Occi::Core::Errors::ParsingError) { model.find_by_identifier!(mxn) }
             end
 
+            logger.debug "Created link instance #{link.inspect} from #{md.inspect}" if logger_debug?
             link
           end
 
@@ -196,13 +210,16 @@ module Occi
           # @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"
+              raise Occi::Core::Errors::ParsingError, "Link #{link.id} is missing attribute information"
             end
+            logger.debug "Parsing inline link attributes from line #{md[:attributes].inspect}" if logger_debug?
 
+            regexp = Regexp.new "(\\s*#{Constants::REGEXP_ATTRIBUTE_REPR})"
             line = md[:attributes].strip.gsub(/^;\s*/, '')
-            attrs = line.split(';').map { |attrb| "#{TextParser::ATTRIBUTE_KEYS.first}: #{attrb}" }
-            plain_attributes! attrs, link.attributes
+            plain_attributes!(
+              line.scan(regexp).map { |attrb| "#{TextParser::ATTRIBUTE_KEYS.first}: #{attrb.first}" },
+              link.attributes
+            )
 
             link
           end
@@ -214,10 +231,10 @@ module Occi
           # @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"
+              raise Occi::Core::Errors::ParsingError, 'Cannot typecast (un)set value to (un)set type'
             end
 
+            logger.debug "Typecasting value #{value.inspect} to #{type}" if logger_debug?
             self.class.typecaster[type].call(value)
           end
 

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

@@ -11,6 +11,10 @@ module Occi
           include Helpers::ErrorHandler
 
           class << self
+            # Shortcuts to interesting methods on logger
+            DELEGATED = %i[debug? info? warn? error? fatal?].freeze
+            delegate(*DELEGATED, to: :logger, prefix: true)
+
             # Parses text/plain OCCI locations into `URI` instances suitable for futher processing.
             # Every location line is expected to begin with 'X-OCCI-Location'.
             #
@@ -18,15 +22,19 @@ module Occi
             # @return [Array] list of locations (URIs)
             def plain(lines)
               regexp = Regexp.new(Constants::REGEXP_LOCATION)
-              lines.map do |line|
+
+              locations = lines.map do |line|
                 next if line.blank?
+                logger.debug "Parsing location from line #{line.inspect}" if logger_debug?
+
                 matched = line.match(regexp)
                 unless matched
-                  raise Occi::Core::Errors::ParsingError,
-                        "#{self} -> #{line.inspect} does not match 'X-OCCI-Location: URI'"
+                  raise Occi::Core::Errors::ParsingError, "#{line.inspect} does not match 'X-OCCI-Location: URI'"
                 end
                 handle(Occi::Core::Errors::ParsingError) { URI.parse(matched[:location].strip) }
-              end.compact
+              end
+
+              locations.compact
             end
 
             # Parses text/uri-list lines into `URI` instances suitable for futher processing.
@@ -35,10 +43,14 @@ module Occi
             # @param lines [Array] list of lines to parse
             # @return [Array] list of locations (URIs)
             def uri_list(lines)
-              lines.map do |line|
+              uris = lines.map do |line|
                 next if line.blank? || line.start_with?('#')
+                logger.debug "Parsing location from line #{line.inspect}" if logger_debug?
+
                 handle(Occi::Core::Errors::ParsingError) { URI.parse(line.strip) }
-              end.compact
+              end
+
+              uris.compact
             end
           end
         end

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

@@ -50,14 +50,15 @@ module Occi
         # @return [Set] set of instances
         def entities(body, headers, expectation = nil)
           expectation ||= Occi::Core::Entity
+          logger.debug "Parsing #{expectation} from #{body.inspect} and #{headers.inspect}" if logger_debug?
 
           entity_parser = Text::Entity.new(model: model)
           entity = entity_parser.plain transform(body, headers)
           unless entity.is_a?(expectation)
-            raise Occi::Core::Errors::ParsingError, "#{self.class} -> Given entity isn't #{expectation}"
+            raise Occi::Core::Errors::ParsingError, "Entity is not of type #{expectation}"
           end
 
-          Set.new([entity].compact)
+          setify(entity)
         end
 
         # Parses action instances from the given body/headers. Only actions already declared in the model are
@@ -67,16 +68,15 @@ module Occi
         # @param headers [Hash] raw headers as provided by the transport protocol
         # @return [Set] set of parsed instances
         def action_instances(body, headers)
+          logger.debug "Parsing Occi::Core::ActionInstance from #{body.inspect} and #{headers.inspect}" if logger_debug?
           entity_parser = Text::Entity.new(model: model)
           tformed = transform(body, headers)
 
-          cats = entity_parser.plain_categories tformed
-          action = cats.detect { |c| c.is_a? Occi::Core::Action }
-          raise Occi::Core::Errors::ParsingError, "#{self.class} -> AI does not specify action" unless action
-
-          ai = Occi::Core::ActionInstance.new(action: action)
-          entity_parser.plain_attributes! tformed, ai.attributes
-          Set.new([ai].compact)
+          action_instance = Occi::Core::ActionInstance.new(
+            action: action_instance_category(entity_parser, tformed)
+          )
+          entity_parser.plain_attributes! tformed, action_instance.attributes
+          setify(action_instance)
         end
 
         # Parses categories from the given body/headers and returns corresponding instances
@@ -88,11 +88,14 @@ module Occi
         # @return [Set] set of instances
         def categories(body, headers, expectation = nil)
           expectation ||= Occi::Core::Category
+          logger.debug "Parsing #{expectation} from #{body.inspect} and #{headers.inspect}" if logger_debug?
+
           cats = transform(body, headers).map do |line|
             cat = Text::Category.plain_category(line, false)
             lookup "#{cat[:scheme]}#{cat[:term]}", expectation
           end
-          Set.new(cats)
+
+          setify(cats)
         end
 
         # Transforms `body` and `headers` into an array of lines parsable by 'text/plain'
@@ -116,13 +119,16 @@ module Occi
           # @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)
+            if logger_debug?
+              logger.debug "Parsing model from #{media_type.inspect} in #{body.inspect} and #{headers.inspect}"
+            end
+
             if HEADERS_TEXT_TYPES.include? media_type
               Text::Category.plain transform_headers(headers), model
             elsif PLAIN_TEXT_TYPES.include? media_type
               Text::Category.plain transform_body(body), model
             else
-              raise Occi::Core::Errors::ParsingError,
-                    "#{self} -> model cannot be parsed from #{media_type.inspect}"
+              raise Occi::Core::Errors::ParsingError, "Model cannot be parsed from #{media_type.inspect}"
             end
           end
 
@@ -133,6 +139,10 @@ module Occi
           # @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)
+            if logger_debug?
+              logger.debug "Parsing locations from #{media_type.inspect} in #{body.inspect} and #{headers.inspect}"
+            end
+
             if URI_LIST_TYPES.include? media_type
               Text::Location.uri_list transform_body(body)
             elsif HEADERS_TEXT_TYPES.include? media_type
@@ -148,6 +158,7 @@ module Occi
           # @param body [String] multi-line body
           # @return [Array] an array of lines
           def transform_body(body)
+            return [] if body.blank?
             lines = body.respond_to?(:lines) ? body.lines : body.split("\n")
             lines.map(&:strip)
           end
@@ -159,6 +170,7 @@ module Occi
           # @param headers [Hash] hash with raw header key-value pairs
           # @return [Array] an array of body-like lines
           def transform_headers(headers)
+            logger.debug "Transforming headers #{headers.inspect}" if logger_debug?
             unify_headers(
               canonize_headers(
                 normalize_headers(headers)
@@ -172,11 +184,15 @@ module Occi
           # @param headers [Hash] hash with raw header key-value pairs
           # @return [Hash] a cleaner hash with relevant headers
           def normalize_headers(headers)
+            return {} unless headers
+
             headers = Hash[
               headers.map { |k, v| [k.gsub(HEADER_HTTP_PREFIX, '').capitalize, v] }
             ]                                                 # remove 'HTTP_' prefix in keys
             headers.delete_if { |_k, v| v.blank? }            # remove pairs with empty values
             headers.keep_if { |k, _v| OCCI_KEYS.include?(k) } # drop non-OCCI pairs
+
+            logger.debug "Normalized headers #{headers.inspect}" if logger_debug?
             headers
           end
 
@@ -194,6 +210,7 @@ module Occi
               canonical[pref.first] = [canonize_header_value(value)].flatten
             end
 
+            logger.debug "Canonized headers #{canonical.inspect}" if logger_debug?
             canonical
           end
 
@@ -219,6 +236,8 @@ module Occi
             headers.each_pair do |k, v|
               lines << v.map { |val| "#{k}: #{val}" }
             end
+
+            logger.debug "Unified headers #{lines.inspect}" if logger_debug?
             lines.flatten.sort
           end
 
@@ -230,8 +249,7 @@ module Occi
           def validate_header_keys!(headers_keys)
             return unless key_name_groups.any? { |elm| (headers_keys & elm).count > 1 }
 
-            raise Occi::Core::Errors::ParsingError,
-                  "#{self} -> Headers #{headers_keys.inspect} contain mixed key notations"
+            raise Occi::Core::Errors::ParsingError, "Headers #{headers_keys.inspect} contain mixed key notations"
           end
 
           # Returns a list of available key name groups accessible as constants by name on this class.
@@ -244,6 +262,19 @@ module Occi
 
         protected
 
+        # :nodoc:
+        def action_instance_category(entity_parser, action_instance)
+          cats = entity_parser.plain_categories action_instance
+          action = cats.detect { |c| c.is_a? Occi::Core::Action }
+          raise Occi::Core::Errors::ParsingError, 'ActionInstance does not specify action' unless action
+          action
+        end
+
+        # :nodoc:
+        def setify(object)
+          object.is_a?(Enumerable) ? Set.new(object) : Set.new([object].compact)
+        end
+
         # :nodoc:
         def post_initialize(args)
           super

data/lib/occi/core/renderer_factory.rb

@@ -31,7 +31,7 @@ module Occi
       def initialize(args = {})
         default_args! args
 
-        logger.debug "RendererFactory: Initializing with #{args.inspect}"
+        logger.debug "Initializing RendererFactory with #{args.inspect}"
         @required_methods = args.fetch(:required_methods)
         @namespace = args.fetch(:namespace)
 
@@ -40,7 +40,7 @@ module Occi
 
       #
       def reload!
-        logger.debug 'RendererFactory: Clearing cache for renderer reload'
+        logger.debug 'Clearing RendererFactory cache for renderer reload'
         @ravail_cache = nil
       end
 
@@ -65,7 +65,7 @@ module Occi
         @ravail_cache = {}
 
         renderer_classes.each do |rndr_klass|
-          logger.debug "RendererFactory: Registering #{rndr_klass} for #{rndr_klass.formats}"
+          logger.debug "RendererFactory registering #{rndr_klass} for #{rndr_klass.formats}"
           rndr_klass.formats.each { |rndr_klass_f| @ravail_cache[rndr_klass_f] = rndr_klass }
         end
 
@@ -113,7 +113,7 @@ module Occi
           renderer_with_methods! candidate
           renderer_with_formats! candidate
         rescue Occi::Core::Errors::RendererError => ex
-          logger.debug "RendererFactory: Renderer validation failed with #{ex.message}"
+          logger.debug "Renderer validation failed with #{ex.message}"
           return false
         end
 
@@ -176,7 +176,7 @@ module Occi
             raise Occi::Core::Errors::RendererError, "#{namespace.inspect} " \
                   'is not a Module'
           end
-          logger.debug "RendererFactory: Looking for renderers in #{namespace}"
+          logger.debug "RendererFactory looking for renderers in #{namespace}"
           namespace.constants.collect { |const| namespace.const_get(const) }
         end
 

data/lib/occi/core/version.rb

@@ -3,7 +3,7 @@ module Occi
     MAJOR_VERSION = 5                # Major update constant
     MINOR_VERSION = 0                # Minor update constant
     PATCH_VERSION = 0                # Patch/Fix version constant
-    STAGE_VERSION = 'alpha.4'.freeze # use `nil` for production releases
+    STAGE_VERSION = 'beta.1'.freeze # use `nil` for production releases
 
     unless defined?(::Occi::Core::VERSION)
       VERSION = [

data/lib/occi/core/warehouse.rb

@@ -29,7 +29,7 @@ module Occi
         #
         # @param model [Occi::Core::Model] model to be bootstrapped
         def bootstrap!(model)
-          logger.debug "#{self}: Bootstrapping#{model.empty? ? ' empty' : ''} model"
+          logger.debug "Bootstrapping#{model.empty? ? ' empty' : ''} model"
           actions! model
           kinds! model
           mixins! model
@@ -67,7 +67,7 @@ module Occi
         def kinds!(model)
           attribute_definitions = attribute_definitions_for(kinds_path)
           yamls_in(kinds_path).each do |file|
-            logger.debug "#{self}: Loading kind from #{file.inspect}"
+            logger.debug "Warehouse loading kind from #{file.inspect}"
             model << Occi::Core::Kind.from_yaml(file, model, attribute_definitions)
           end
         end
@@ -76,7 +76,7 @@ module Occi
         def mixins!(model)
           attribute_definitions = attribute_definitions_for(mixins_path)
           yamls_in(mixins_path).each do |file|
-            logger.debug "#{self}: Loading mixin from #{file.inspect}"
+            logger.debug "Warehouse loading mixin from #{file.inspect}"
             model << Occi::Core::Mixin.from_yaml(file, model, attribute_definitions)
           end
         end
@@ -86,7 +86,7 @@ module Occi
           # TODO: work with separate attribute definitions
           attribute_definitions = {}
           yamls_in(actions_path).each do |file|
-            logger.debug "#{self}: Loading action from #{file.inspect}"
+            logger.debug "Warehouse loading action from #{file.inspect}"
             model << Occi::Core::Action.from_yaml(file, model, attribute_definitions)
           end
         end
@@ -98,7 +98,7 @@ module Occi
           attr_defs_path = File.join(categories_path, ATTRIBS)
           yamls_in(attr_defs_path).each do |file|
             name = attribute_name_from(file)
-            logger.debug "#{self}: Loading attribute definition for #{name.inspect} from #{file.inspect}"
+            logger.debug "Warehouse loading attribute definition for #{name.inspect} from #{file.inspect}"
             attribute_definitions[name] = Occi::Core::AttributeDefinition.from_yaml(file)
           end
 

data/lib/occi/infrastructure/model.rb

@@ -10,7 +10,7 @@ module Occi
       #    model = Occi::Infrastructure::Model.new
       #    model.load_infrastructure!
       def load_infrastructure!
-        logger.debug "#{self.class}: Loading Infrastructure from Warehouse"
+        logger.debug 'Loading Infrastructure from Infrastructure::Warehouse'
         Occi::Infrastructure::Warehouse.bootstrap! self
         self << Occi::Infrastructure::Mixins::OsTpl.new
         self << Occi::Infrastructure::Mixins::ResourceTpl.new

data/lib/occi/infrastructure_ext/model.rb

@@ -10,7 +10,7 @@ module Occi
       #    model = Occi::InfrastructureExt::Model.new
       #    model.load_infrastructure_ext!
       def load_infrastructure_ext!
-        logger.debug "#{self.class}: Loading InfrastructureExt from Warehouse"
+        logger.debug 'Loading InfrastructureExt from InfrastructureExt::Warehouse'
         Occi::InfrastructureExt::Warehouse.bootstrap! self
         self << Occi::InfrastructureExt::Mixins::AvailabilityZone.new
         nil

data/lib/occi/monkey_island/hash.rb

@@ -1,4 +1,5 @@
 # :nodoc:
 class Hash
+  include Yell::Loggable
   include Occi::Core::Helpers::HashDereferencer
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: occi-core
 version: !ruby/object:Gem::Version
-  version: 5.0.0.alpha.4
+  version: 5.0.0.beta.1
 platform: ruby
 authors:
 - Boris Parak
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-05-15 00:00:00.000000000 Z
+date: 2017-06-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json
@@ -566,7 +566,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: 1.3.1
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.8
+rubygems_version: 2.6.10
 signing_key: 
 specification_version: 4
 summary: The rOCCI toolkit