occi-core 4.3.6 → 5.0.0.alpha.1

data/.yardopts

@@ -1 +0,0 @@
---title "Documentation of the OCCI gem" --markup markdown --private

data/config/occi.yml

@@ -1,4 +0,0 @@
-# config/occi.yml
-core: &core
-  compatibility: true
-  verify_attribute_pattern: false

data/lib/occi/collection.rb

@@ -1,265 +0,0 @@
-module Occi
-  class Collection
-
-    include Occi::Helpers::Inspect
-    include Occi::Helpers::Comparators::Collection
-
-    attr_accessor :kinds, :mixins, :actions, :resources, :links, :action, :model
-
-    # Initialize a new OCCI Collection by initializing all supplied OCCI objects
-    #
-    # @param [Hash] collection including one or more of the keys kinds, mixins, actions, resources, links
-    def initialize(collection={}, model = Occi::Model.new)
-      collection = Hashie::Mash.new(collection) unless collection.kind_of? Occi::Collection
-
-      @kinds = Occi::Core::Kinds.new
-      @mixins = Occi::Core::Mixins.new
-      @actions = Occi::Core::Actions.new
-      @resources = Occi::Core::Resources.new
-      @links = Occi::Core::Links.new
-
-      @kinds.merge collection.kinds.to_a.collect { |kind| Occi::Core::Kind.new(kind.scheme, kind.term, kind.title, kind.attributes, kind.related, kind.actions, kind.location) }
-      @mixins.merge collection.mixins.to_a.collect { |mixin| Occi::Core::Mixin.new(mixin.scheme, mixin.term, mixin.title, mixin.attributes, mixin.depends, mixin.actions, mixin.location, mixin.applies) }
-      @actions.merge collection.actions.to_a.collect { |action| Occi::Core::Action.new(action.scheme, action.term, action.title, action.attributes) }
-      @resources.merge collection.resources.to_a.collect { |resource| Occi::Core::Resource.new(resource.kind, resource.mixins, resource.attributes, resource.actions, resource.links, resource.location) }
-      @links.merge collection.links.to_a.collect { |link| Occi::Core::Link.new(link.kind, link.mixins, link.attributes, link.actions, link.rel, link.target, link.source, link.location) }
-      @action = Occi::Core::ActionInstance.new(collection.action.action, collection.action.attributes) if collection.action
-
-      self.model = model if model
-    end
-
-    def <<(object)
-      self.kinds << object if object.kind_of? Occi::Core::Kind
-      self.mixins << object if object.kind_of? Occi::Core::Mixin
-      self.actions << object if object.kind_of? Occi::Core::Action
-      self.resources << object if object.kind_of? Occi::Core::Resource
-      self.links << object if object.kind_of? Occi::Core::Link
-
-      self.action = object if object.kind_of? Occi::Core::ActionInstance
-
-      self
-    end
-
-    # @return [Occi::Core::Categories] categories combined list of all kinds, mixins and actions
-    def categories
-      Occi::Core::Categories.new(@kinds + @mixins + @actions)
-    end
-
-    # @return [Occi::Core::Entities] entities combined list of all resources and links
-    def entities
-      Occi::Core::Entities.new(@resources + @links)
-    end
-
-    # @param [Occi::Core::Model] model
-    # @return [Occi::Core::Model]
-    def model=(model)
-      @model = model
-
-      @kinds.model = model
-      @mixins.model = model
-      @actions.model = model
-      @resources.model = model
-      @links.model = model
-
-      @action.model = model if @action
-    end
-
-    # @param incl_categories [Boolean] check every category against the model
-    # @param set_default_attrs [Boolean] set default attribute values for all entities
-    # @return [Boolean] result
-    def check(incl_categories = false, set_default_attrs = false)
-      @resources.check(set_default_attrs)
-      @links.check(set_default_attrs)
-      @action.check(set_default_attrs) if @action
-
-      if incl_categories
-        @kinds.check
-        @mixins.check
-        @actions.check
-      end
-
-      true
-    end
-
-    # @param [Occi::Collection] other_collection
-    # @return [Occi::Collection]
-    def merge!(other_collection)
-      self.kinds.merge other_collection.kinds.select { |kind| get_by_id(kind.type_identifier).nil? }
-      self.mixins.merge other_collection.mixins.select { |mixin| get_by_id(mixin.type_identifier).nil? }
-      self.actions.merge other_collection.actions.select { |action| get_by_id(action.type_identifier).nil? }
-      self.resources.merge other_collection.resources.select { |resource| get_by_id(resource.id).nil? }
-      self.links.merge other_collection.links.select { |link| get_by_id(link.id).nil? }
-      self.action = other_collection.action if other_collection.action
-    end
-
-    # @param [Occi::Collection] other_collection
-    # @param [Occi::Collection] collection
-    # @return [Occi::Collection]
-    def merge(other_collection, first=self)
-      collection = Occi::Collection.new
-
-      collection.merge!(first)
-      collection.merge!(other_collection)
-
-      collection
-    end
-
-    # @param [Occi::Collection] other_collection
-    # @return [Occi::Collection]
-    def intersect!(other_collection)
-      intersect other_collection, self
-    end
-
-    # @param [Occi::Collection] other_collection
-    # @param [Occi::Collection] collection
-    # @return [Occi::Collection]
-    def intersect(other_collection, collection=self.clone)
-      collection.kinds.replace other_collection.kinds.select { |kind| get_by_id(kind.type_identifier) }
-      collection.mixins.replace other_collection.mixins.select { |mixin| get_by_id(mixin.type_identifier) }
-      collection.actions.replace other_collection.actions.select { |action| get_by_id(action.type_identifier) }
-      collection.resources.replace other_collection.resources.select { |resource| get_by_id(resource.id) }
-      collection.links.replace other_collection.links.select { |link| get_by_id(link.id) }
-
-      if collection.action == other_collection.action
-        collection.action = other_collection.action
-      else
-        collection.action = nil
-      end
-
-      collection
-    end
-
-    # Returns the category corresponding to a given id
-    #
-    # @param id [String] identifier
-    # @param cats_only [Boolean] look only for categories
-    # @return [Occi::Core::Category]
-    def get_by_id(id, cats_only = false)
-      raise "Cannot do a look-up with a blank id!" if id.blank?
-      object = self.categories.select { |category| category.type_identifier == id }
-      object = self.entities.select { |entity| entity.id == id } if !cats_only && object.empty?
-      object.first
-    end
-
-    # Returns the category corresponding to a given location
-    #
-    # @param [String] location
-    # @return [Occi::Core::Category]
-    def get_by_location(location)
-      raise "Cannot do a look-up with a blank location!" if location.blank?
-      self.categories.select { |category| category.location == instance2cat(location) }.first
-    end
-
-    # @return [true,false] true if collection is empty, false otherwise
-    def empty?
-      @kinds.empty? && @mixins.empty? && @actions.empty? && @resources.empty? && @links.empty? && @action.nil?
-    end
-
-    # Returns a collection with all categories related to the specified category
-    #
-    # @param [Occi::Core::Category, String] category
-    # @return [Occi::Core::Collection]
-    def get_related_to(category)
-      raise "Cannot do a look-up with a blank category!" if category.blank?
-      collection = self.class.new
-      collection.kinds = @kinds.get_related_to(category)
-      collection.mixins = @mixins.get_related_to(category)
-      collection
-    end
-
-    # @return [Hashie::Mash] json representation
-    def as_json(options = {})
-      return @action.as_json if standalone_action_instance?
-
-      collection = Hashie::Mash.new
-      collection.kinds = @kinds.collect { |kind| kind.as_json } if @kinds.any?
-      collection.mixins = @mixins.collect { |mixin| mixin.as_json } if @mixins.any?
-      collection.actions = @actions.collect { |action_category| action_category.as_json } if @actions.any?
-      collection.resources = @resources.collect { |resource| resource.as_json } if @resources.any?
-
-      # if there is only one resource and the links inside the resource have no location,
-      # then these links must be rendered as separate links inside the collection
-      if collection.resources && collection.resources.size == 1
-        if collection.resources.first.links.blank? && @links.empty?
-          lnks = @resources.first.links
-        else
-          lnks = @links
-        end
-      else
-        lnks = @links
-      end
-      collection.links = lnks.collect { |link| link.as_json } if lnks.to_a.any?
-
-      collection
-    end
-
-    # @return [String] text representation
-    def to_text
-      text = ""
-
-      if standalone_links?
-        raise "Only one standalone link allowed for rendering to text/plain!" if self.links.size > 1
-        text << self.links.first.to_text
-      elsif standalone_action_instance?
-        text << self.action.to_text
-      else
-        text << self.categories.collect { |category| category.to_text }.join("\n")
-        text << "\n" if self.categories.any?
-        raise "Only one resource allowed for rendering to text/plain!" if self.resources.size > 1
-        text << self.resources.first.to_text if self.resources.any?
-        text << self.links.collect { |link| link.to_text_link }.join("\n")
-        text << self.action.to_text if self.action
-      end
-
-      text
-    end
-
-    def to_header
-      header = Hashie::Mash.new
-
-      if standalone_links?
-        raise "Only one standalone link allowed for rendering to text/occi!" if self.links.size > 1
-        header = self.links.first.to_header
-      elsif standalone_action_instance?
-        header = self.action.to_header
-      else
-        header['Category'] = self.categories.collect { |category| category.to_string }.join(',') if self.categories.any?
-        raise "Only one resource allowed for rendering to text/occi!" if self.resources.size > 1
-        header = self.class.header_merge(header, self.resources.first.to_header) if self.resources.any?
-        header['Link'] = self.links.collect { |link| link.to_string }.join(',') if self.links.any?
-        header = self.class.header_merge(header, self.action.to_header) if self.action
-      end
-
-      header
-    end
-
-    private
-
-    def self.header_merge(target, other, separator=',')
-      other.each_pair do |key,val|
-        if target.key?(key)
-          target[key] = "#{target[key]}#{separator}#{val}"
-        else
-          target[key] = val
-        end
-      end
-      target
-    end
-
-    def standalone_links?
-      !self.links.blank? && self.categories.blank? && self.resources.blank? && self.action.blank?
-    end
-
-    def standalone_action_instance?
-      !self.action.blank? && self.categories.blank? && self.entities.blank?
-    end
-
-    def instance2cat(location)
-      return location if location.start_with?('/') && location.end_with?('/')
-      cat_relative_uri = "#{File.dirname(URI.parse(location).path)}/"
-      raise "Supplied location is invalid! #{cat_relative_uri.inspect}" unless cat_relative_uri =~ /\/.+\//
-      cat_relative_uri
-    end
-
-  end
-end

data/lib/occi/core/actions.rb

@@ -1,21 +0,0 @@
-module Occi
-  module Core
-    class Actions < Occi::Core::Categories
-
-      private
-
-      def convert(category)
-        category = super category
-
-        if category.kind_of? String
-          scheme, term = category.split '#'
-          scheme << '#'
-          category = Occi::Core::Action.new(scheme, term)
-        end
-
-        category
-      end
-
-    end
-  end
-end

data/lib/occi/core/attributes.rb

@@ -1,411 +0,0 @@
-module Occi
-  module Core
-    class Attributes < Hashie::Mash
-
-      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
-      end
-
-      def [](key)
-        if key.to_s.include? '.'
-          key, string = key.to_s.split('.', 2)
-          attributes = super(key)
-          raise Occi::Errors::AttributeMissingError,
-                "Attribute with key #{key} not found" unless attributes
-          attributes[string]
-        else
-          super(key)
-        end
-      end
-
-      def []=(key, value)
-        if key.to_s.include? '.'
-          key, string = key.to_s.split('.', 2)
-          super(key, Occi::Core::Attributes.new) unless self[key].kind_of? Occi::Core::Attributes
-          self[key][string] = value
-        else
-          property_key = "_#{key.to_s}"
-          validate_and_assign(key, value, property_key)
-        end
-      end
-
-      def remove(attributes)
-        attributes.keys.each do |key|
-          next unless self.keys.include?(key)
-
-          case self[key]
-          when Occi::Core::Attributes
-            self[key].remove attributes[key]
-          else
-            self.delete(key)
-          end
-        end
-
-        self
-      end
-
-      def convert(attributes=Occi::Core::Attributes.new(self))
-        attributes.each_pair do |key, value|
-          next if key =~ /^_/
-          case value
-          when Occi::Core::Attributes
-            value.convert!
-          else
-            attributes[key] = nil
-          end
-        end
-
-        attributes.converted = true
-        attributes
-      end
-
-      def convert!
-        convert self
-      end
-
-      # @return [Hash] key value pair of full attribute names with their corresponding values
-      def names
-        hash = {}
-        self.each_key do |key|
-          next if key =~ /^_/
-          if self[key].kind_of? Occi::Core::Attributes
-            self[key].names.each_pair { |k, v| hash["#{key}.#{k}"] = v unless v.nil? }
-          else
-            hash[key] = self[key]
-          end
-        end
-
-        hash
-      end
-
-      # @param [Hash] attributes
-      # @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 Occi::Core::Properties.contains_props?(value)
-            value = value.to_hash if value.kind_of?(Hashie::Mash)
-            attributes[key] = Occi::Core::Properties.new(value)
-          else
-            attributes[key] = self.parse_properties(value)
-          end
-        end
-
-        attributes
-      end
-
-      # @param [Hash] attributes key value pair of full attribute names with their corresponding values
-      # @return [Occi::Core::Attributes]
-      def self.split(attributes)
-        attribute = Attributes.new
-        attributes.each do |name, value|
-          key, _, rest = name.partition('.')
-          if rest.blank?
-            attribute[key] = value
-          else
-            attribute.merge! Attributes.new(key => self.split(rest => value))
-          end
-        end
-
-        attribute
-      end
-
-      # @return [String]
-      def to_string
-        attributes = ';'
-        attributes << to_array.join(';')
-
-        attributes == ';' ? '' : attributes
-      end
-
-      # @return [String]
-      def to_string_short
-        any? ? ";attributes=#{names.keys.collect { |key| name_w_props(key) }.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 [Array] of attributes put in an array
-      def to_array
-        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
-      end
-
-      # @return [String] of attributes put in an array and then concatenated into a string
-      def to_header
-        to_array.join(',')
-      end
-
-      def to_json(*a)
-        as_json(*a).to_json(*a)
-      end
-
-      # @param [Hash] options
-      # @return [Hashie::Mash] json representation
-      def as_json(options={})
-        hash = Hashie::Mash.new
-        self.each_pair do |key, value|
-          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 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
-
-      # @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, 'string', self[property_key]) if self[property_key]
-          add_to_hashie(key, value)
-        when Occi::Core::Category
-          match_type(value, 'string', self[property_key]) if self[property_key]
-          add_to_hashie(key, value)
-        when String
-          value = interpret_string(value, self[property_key]) if self[property_key]
-          add_to_hashie(key, value)
-        when Numeric
-          match_type(value, 'number', self[property_key]) if self[property_key]
-          add_to_hashie(key, value)
-        when FalseClass, TrueClass
-          match_type(value, 'boolean', self[property_key]) 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 interpret_string(value, property)
-        if property.type == 'number' && (/^[.0-9]+$/ =~ value)
-          value = (/^[0-9]+$/ =~ value) ? value.to_i : value.to_f
-          match_type(value, 'number', property)
-        elsif property.type == 'boolean'
-          value = if value.casecmp("yes") == 0 || value.casecmp("true") == 0
-                    true
-                  elsif value.casecmp("no") == 0 || value.casecmp("false") == 0
-                    false
-                  else
-                    value
-                  end
-
-          match_type(value, 'boolean', property)
-        else
-          match_type(value, 'string', property)
-        end
-
-        value
-      end
-
-      def match_type(value, value_type, property)
-        raise Occi::Errors::AttributeTypeError,
-              "Value #{value} derived from #{value.class} assigned " \
-              "but attribute of type #{property.type} required" unless property.type == value_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.debug "[#{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
-            attributes[key] = Occi::Core::Attributes.new if attributes[key].nil?
-            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
-            elsif definitions[key].required || set_defaults
-              attributes[key] = definitions[key]
-              attributes[key] = definitions[key].default
-            end
-          else
-            old_val = attributes[key]
-            attributes[key] = definitions[key]
-            attributes[key] = old_val
-          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.debug "[#{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
-
-      def name_w_props(attribute_name)
-        return attribute_name if attribute_name.blank?
-
-        parts = attribute_name.split('.')
-        parts[parts.length - 1] = "_#{parts.last}"
-        property_name = parts.join('.')
-
-        return attribute_name unless self[property_name]
-
-        props = []
-        props << "immutable" if !self[property_name].mutable
-        props << "required" if self[property_name].required
-
-        attribute_name = "#{attribute_name}{#{props.join(' ')}}" unless props.empty?
-
-        attribute_name
-      end
-
-    end
-  end
-end