occi-core 4.1.3 → 4.2.0

data/lib/occi/core/attributes.rb

@@ -5,6 +5,18 @@ module Occi
       attr_accessor :converted
 
       include Occi::Helpers::Inspect
+      include Occi::Helpers::Comparators::Attributes
+
+      def initialize(source_hash = {}, default = nil, &blk)
+        raise ArgumentError, 'Source_hash is a mandatory argument!' unless source_hash
+        raise ArgumentError, 'Source_hash must be a hash-like structure!' unless source_hash.kind_of?(Hash)
+
+        # All internal Hashie::Mash elements in source_hash have to be re-typed
+        # to Occi::Core::Attributes, so we have to rebuild the object from scratch
+        source_hash = source_hash.to_hash unless source_hash.kind_of?(Occi::Core::Attributes)
+
+        super(source_hash, default, &blk)
+      end
 
       def converted?
         @converted||=false
@@ -14,7 +26,8 @@ module Occi
         if key.to_s.include? '.'
           key, string = key.to_s.split('.', 2)
           attributes = super(key)
-          raise "Attribute with key #{key} not found" unless attributes
+          raise Occi::Errors::AttributeMissingError,
+                "Attribute with key #{key} not found" unless attributes
           attributes[string]
         else
           super(key)
@@ -27,34 +40,8 @@ module Occi
           super(key, Occi::Core::Attributes.new) unless self[key].kind_of? Occi::Core::Attributes
           self[key][string] = value
         else
-          property_key = '_' + key.to_s
-          case value
-            when Occi::Core::Attributes
-              super(key, value)
-            when Occi::Core::Properties
-              super(key, value.clone)
-              super(property_key, value.clone)
-            when Hash
-              properties = Occi::Core::Properties.new(value)
-              super(key, properties.clone)
-              super(property_key, properties.clone)
-            when Occi::Core::Entity
-              raise "value #{value} derived from Occi::Core::Entity assigned but attribute of type #{self[property_key].type} required" unless self[property_key].type == 'string' if self[property_key]
-              raise "value #{value} does not match pattern" unless value.to_s.match '^' + self[property_key].pattern + '$' if Occi::Settings.verify_attribute_pattern if self[property_key]
-              super(key, value)
-            when String
-              raise "value #{value} of type String assigned but attribute of type #{self[property_key].type} required" unless self[property_key].type == 'string' if self[property_key]
-              raise "value #{value} does not match pattern" unless value.match '^' + self[property_key].pattern + '$' if Occi::Settings.verify_attribute_pattern if self[property_key]
-              super(key, value)
-            when Numeric
-              raise "value #{value} of type String assigned but attribute of type #{self[property_key].type} required" unless self[property_key].type == 'number' if self[property_key]
-              raise "value #{value} does not match pattern" unless value.to_s.match '^' + self[property_key].pattern + '$' if Occi::Settings.verify_attribute_pattern if self[property_key]
-              super(key, value)
-            when NilClass
-              super(key, value)
-            else
-              raise "value #{value} of type #{value.class} not supported as attribute"
-          end
+          property_key = "_#{key.to_s}"
+          validate_and_assign(key, value, property_key)
         end
       end
 
@@ -62,10 +49,10 @@ module Occi
         attributes.keys.each do |key|
           if self.keys.include? key
             case self[key]
-              when Occi::Core::Attributes
-                self[key].remove attributes[key]
-              else
-                self.delete(key)
+            when Occi::Core::Attributes
+              self[key].remove attributes[key]
+            else
+              self.delete(key)
             end
           end
         end
@@ -74,12 +61,12 @@ module Occi
 
       def convert(attributes=Occi::Core::Attributes.new(self))
         attributes.each_pair do |key, value|
-          next if attributes.key?(key[1..-1])
+          next if key =~ /^_/
           case value
-            when Occi::Core::Attributes
-              value.convert!
-            else
-              attributes[key] = nil
+          when Occi::Core::Attributes
+            value.convert!
+          else
+            attributes[key] = nil
           end
         end
         attributes.converted = true
@@ -90,13 +77,13 @@ module Occi
         convert self
       end
 
-      # @return [Array] key value pair of full attribute names with their corresponding values
+      # @return [Hash] key value pair of full attribute names with their corresponding values
       def names
         hash = {}
         self.each_key do |key|
-          next if self.key?(key[1..-1])
+          next if key =~ /^_/
           if self[key].kind_of? Occi::Core::Attributes
-            self[key].names.each_pair { |k, v| hash[key + '.' + k] = v unless v.blank? }
+            self[key].names.each_pair { |k, v| hash["#{key}.#{k}"] = v unless v.nil? }
           else
             hash[key] = self[key]
           end
@@ -105,45 +92,89 @@ module Occi
       end
 
       # @param [Hash] attributes
-      # @return [Occi::Core::Properties] parsed Properties
-      def self.parse(hash)
+      # @return [Occi::Core::Attributes] parsed attributes with properties
+      def self.parse_properties(hash)
         hash ||= {}
+        raise Occi::Errors::ParserInputError,
+              'Hash must be a hash-like structure!' unless hash.respond_to?(:each_pair)
+
         attributes = Occi::Core::Attributes.new
         hash.each_pair do |key, value|
-          if [:Type, :Required, :Mutable, :Default, :Description, :Pattern, :type, :required, :mutable, :default, :description, :pattern].any? { |k| value.key?(k) and not value[k].kind_of? Hash }
-            value[:type] ||= value[:Type] ||= "string"
-            value[:required] ||= value[:Required] ||= false
-            value[:mutable] ||= value[:Mutable] ||= false
-            value[:default] = value[:Default] if value[:Default]
-            value[:description] = value[:Description] if value[:Description]
-            value[:pattern] ||= value[:Pattern] ||= ".*"
-            value.delete :Type
-            value.delete :Required
-            value.delete :Mutable
-            value.delete :Default
-            value.delete :Description
-            value.delete :Pattern
-            attributes[key] = Occi::Core::Properties.new value
+          if Occi::Core::Properties.contains_props?(value)
+            attributes[key] = Occi::Core::Properties.new(value)
           else
-            attributes[key] = self.parse attributes[key]
+            attributes[key] = self.parse_properties(attributes[key])
           end
         end
+
         attributes
       end
 
       # @param [Hash] attributes key value pair of full attribute names with their corresponding values
-      # @return [Occi::Core::Properties]
+      # @return [Occi::Core::Attributes]
       def self.split(attributes)
         attribute = Attributes.new
         attributes.each do |name, value|
           key, _, rest = name.partition('.')
-          if rest.empty?
+          if rest.blank?
             attribute[key] = value
           else
             attribute.merge! Attributes.new(key => self.split(rest => value))
           end
         end
-        return attribute
+
+        attribute
+      end
+
+      # @return [String]
+      def to_string
+        attributes = ';'
+        attributes << to_header.gsub(',', ';')
+
+        attributes == ';' ? '' : attributes
+      end
+
+      # @return [String]
+      def to_string_short
+        any? ? ";attributes=#{names.keys.join(' ').inspect}" : ""
+      end
+
+      # @return [String]
+      def to_text
+        text = ""
+        names.each_pair do |name, value|
+          # TODO: find a better way to skip properties
+          next if name.include? '._'
+          case value
+          when Occi::Core::Entity
+            text << "\nX-OCCI-Attribute: #{name}=\"#{value.location}\""
+          when Occi::Core::Category
+            text << "\nX-OCCI-Attribute: #{name}=\"#{value.type_identifier}\""
+          else
+            text << "\nX-OCCI-Attribute: #{name}=#{value.inspect}"
+          end
+        end
+
+        text
+      end
+
+      # @return [String] of attributes put in an array and then concatenated into a string
+      def to_header
+        attributes = []
+        names.each_pair do |name, value|
+          # TODO: find a better way to skip properties
+          next if name.include? '._'
+          case value
+          when Occi::Core::Entity
+            attributes << "#{name}=\"#{value.location}\""
+          when Occi::Core::Category
+            attributes << "#{name}=\"#{value.type_identifier}\""
+          else
+            attributes << "#{name}=#{value.inspect}"
+          end
+        end
+
+        attributes.join(',')
       end
 
       def to_json(*a)
@@ -153,24 +184,173 @@ module Occi
       # @param [Hash] options
       # @return [Hashie::Mash] json representation
       def as_json(options={})
-        hash = {}
+        hash = Hashie::Mash.new
         self.each_pair do |key, value|
-          next if self.key?(key[1..-1])
+          next if key =~ /^_/
+          # TODO: find a better way to skip properties
+          next if key.start_with? '_'
+
           case value
-            when Occi::Core::Attributes
-              hash[key] = value.as_json unless value.as_json.size == 0
-            when Occi::Core::Entity
-              hash[key] = value.to_s unless value.to_s.empty?
-            when Occi::Core::Category
-              hash[key] = value.to_s
-            else
-              hash[key] = value.as_json if value
+          when Occi::Core::Attributes
+            hash[key] = value.as_json if value && value.as_json.size > 0
+          when Occi::Core::Entity
+            hash[key] = value.to_s unless value.blank?
+          when Occi::Core::Category
+            hash[key] = value.to_s
+          else
+            hash[key] = value.as_json unless value.nil?
           end
         end
+
         hash
       end
 
-    end
+      # @param [Occi::Core::Attributes] definitions
+      # @param [true,false] set_defaults
+      # @return [Occi::Core::Attributes] attributes with their defaults set
+      def check(definitions, set_defaults = false)
+        attributes = Occi::Core::Attributes.new(self)
+        attributes.check!(definitions, set_defaults)
+        attributes
+      end
 
+      # @param [Occi::Core::Attributes] definitions
+      # @param [true,false] set_defaults
+      # Assigns default values to attributes
+      def check!(definitions, set_defaults = false)
+        raise Occi::Errors::AttributeDefinitionsConvrertedError,
+              "Definition attributes must not be converted" if definitions.converted?
+
+        # Start with checking for missing attributes
+        add_missing_attributes(self, definitions, set_defaults)
+
+        # Then check all attributes against definitions
+        check_wrt_definitions(self, definitions, set_defaults)
+
+        # Delete remaining empty attributes
+        delete_empty(self)
+      end
+
+      private
+
+      def validate_and_assign(key, value, property_key)
+        raise Occi::Errors::AttributeNameInvalidError,
+              "Attribute names (as in \"#{key}\") must not begin with underscores" if key =~ /^_/
+        case value
+        when Occi::Core::Attributes
+          add_to_hashie(key, value)
+        when Occi::Core::Properties
+          add_to_hashie(key, value.clone)
+          add_to_hashie(property_key, value.clone)
+        when Hash
+          properties = Occi::Core::Properties.new(value)
+          add_to_hashie(key, properties.clone)
+          add_to_hashie(property_key, properties.clone)
+        when Occi::Core::Entity
+          match_type(value, self[property_key], 'string') if self[property_key]
+          add_to_hashie(key, value)
+        when Occi::Core::Category
+          match_type(value, self[property_key], 'string') if self[property_key]
+          add_to_hashie(key, value)
+        when String
+          match_type(value, self[property_key], 'string') if self[property_key]
+          add_to_hashie(key, value)
+        when Numeric
+          match_type(value, self[property_key], 'number') if self[property_key]
+          add_to_hashie(key, value)
+        when FalseClass, TrueClass
+          match_type(value, self[property_key], 'boolean') if self[property_key]
+          add_to_hashie(key, value)
+        when NilClass
+          add_to_hashie(key, value)
+        else
+          raise Occi::Errors::AttributeTypeError,
+                "Value #{value} of type #{value.class} not supported as attribute"
+        end
+      end
+
+      def add_to_hashie(*args)
+        Hashie::Mash.instance_method(:[]=).bind(self).call(*args)
+      end
+
+      def match_type(value, property, expected_type)
+        raise Occi::Errors::AttributeTypeError,
+              "Value #{value} derived from #{value.class} assigned " \
+              "but attribute of type #{property.type} required" unless property.type == expected_type
+        match_pattern(property.pattern, value)
+      end
+
+      def match_pattern(pattern, value)
+        return if pattern.blank?
+
+        if Occi::Settings.verify_attribute_pattern && !Occi::Settings.compatibility
+          raise Occi::Errors::AttributeTypeError,
+                "Value #{value.to_s} does not match pattern #{pattern}" unless value.to_s.match "^#{pattern}$"
+        else
+          Occi::Log.warn "[#{self.class}] Skipping pattern checks on attributes, turn off " \
+                         "the compatibility mode and enable the attribute pattern check in settings!"
+        end
+      end
+
+      def add_missing_attributes(attributes, definitions, set_defaults)
+        definitions.each_key do |key|
+          next if key =~ /^_/
+
+          if definitions[key].kind_of? Occi::Core::Attributes
+            add_missing_attributes(attributes[key], definitions[key], set_defaults)
+          elsif attributes[key].nil?
+
+            if definitions[key].default.nil?
+              raise Occi::Errors::AttributeMissingError,
+                    "Required attribute #{key} not specified" if definitions[key].required
+            else
+              attributes[key] = definitions[key].default if definitions[key].required || set_defaults
+            end
+
+          end
+        end
+      end
+
+      def check_wrt_definitions(attributes, definitions, set_defaults)
+        attributes.each_key do |key|
+          next if key =~ /^_/
+
+          #Raise exception for attributes not defined at all
+          raise Occi::Errors::AttributeNotDefinedError,
+                "Attribute #{key} not found in definitions" unless definitions.key?(key)
+
+          if attributes[key].kind_of? Occi::Core::Attributes
+            check_wrt_definitions(attributes[key], definitions[key], set_defaults)
+          else
+            next if attributes[key].nil? # I will be removed in the next step
+
+            #Check value types
+            definitions[key].check_value_for_type(attributes[key], key)
+
+            # Check patterns
+            if definitions[key].pattern
+              if Occi::Settings.verify_attribute_pattern && !Occi::Settings.compatibility
+                raise Occi::Errors::AttributeTypeError,
+                      "Attribute #{key} with value #{attributes[key]} does not " \
+                      "match pattern #{definitions[key].pattern}" unless attributes[key].to_s.match "^#{definitions[key].pattern}$"
+              else
+                Occi::Log.warn "[#{self.class}] [#{key}] Skipping pattern checks on attributes, turn off " \
+                               "the compatibility mode and enable the attribute pattern check in settings!"
+              end
+            end
+          end
+        end
+      end
+
+      def delete_empty(attributes)
+        attributes.each_key do |key|
+          if attributes[key].kind_of? Occi::Core::Attributes
+            delete_empty(attributes[key])
+          else
+            attributes.delete(key) if attributes[key].nil?
+          end
+        end
+      end
+    end
   end
-end
+end

data/lib/occi/core/categories.rb

@@ -3,6 +3,7 @@ module Occi
     class Categories < Set
 
       include Occi::Helpers::Inspect
+      include Occi::Helpers::Comparators::Categories
 
       attr_accessor :model
 

data/lib/occi/core/category.rb

@@ -3,6 +3,7 @@ module Occi
     class Category
 
       include Occi::Helpers::Inspect
+      include Occi::Helpers::Comparators::Category
 
       attr_accessor :scheme, :term, :title, :attributes, :model
 
@@ -14,21 +15,26 @@ module Occi
           term='category',
           title=nil,
           attributes=Occi::Core::Attributes.new)
-        scheme += '#' unless scheme.end_with? '#'
+        raise ArgumentError, 'scheme and term cannot be nil' unless scheme && term
+        raise ArgumentError, 'scheme and term cannot be empty' if scheme.empty? || term.empty?
+        attributes ||= Occi::Core::Attributes.new
+
+        scheme << '#' unless scheme.end_with? '#'
         @scheme = scheme
         @term = term
         @title = title
+
         case attributes
           when Occi::Core::Attributes
-            @attributes = attributes
+            @attributes = Occi::Core::Attributes.new(attributes)
           else
-            @attributes = Occi::Core::Attributes.parse attributes
+            @attributes = Occi::Core::Attributes.parse_properties attributes
         end
       end
 
       # @return [String] Type identifier of the Category.
       def type_identifier
-        self.scheme + self.term
+        "#{self.scheme}#{self.term}"
       end
 
       # @param options [Hash]
@@ -38,25 +44,25 @@ module Occi
         category.scheme = self.scheme
         category.term = self.term
         category.title = self.title if self.title
-        category.attributes = self.attributes if self.attributes.any?
+        category.attributes = self.attributes.any? ? self.attributes.as_json : Occi::Core::Attributes.new.as_json
         category
       end
 
       # @return [String] Short text representation of the Category.
       def to_string_short
-        self.term + ';scheme=' + self.scheme.inspect + ';class=' + self.class.name.demodulize.downcase.inspect
+        "#{self.term};scheme=#{self.scheme.inspect};class=#{self.class.name.demodulize.downcase.inspect}"
       end
 
       # @return [String] Full text representation of the Category.
       def to_string
         string = self.to_string_short
-        string << ';title=' + self.title.inspect if self.title
+        string << ";title=#{self.title.inspect}" if self.title
         string
       end
 
       # @return [String] Text representation of the Category.
       def to_text
-        'Category: ' + self.to_string
+        "Category: #{self.to_string}"
       end
 
       # @return [Hash] Hash containing the HTTP headers of the text/occi rendering.
@@ -74,6 +80,17 @@ module Occi
         self.type_identifier
       end
 
+      # @return [Bool] Indicating whether this category is "empty", i.e. required attributes are blank
+      def empty?
+        term.blank? || scheme.blank?
+      end
+
+      # @param term [String] Term to check.
+      # @return [Bool] Indicating whether term consists exclusively of valid characters.
+      def self.valid_term?(term)
+        term =~ /^[a-z][a-z0-9_-]*$/
+      end
+
     end
   end
 end

data/lib/occi/core/entities.rb

@@ -3,6 +3,7 @@ module Occi
     class Entities < Set
 
       include Occi::Helpers::Inspect
+      include Occi::Helpers::Comparators::Entities
 
       attr_accessor :model