occi-core 4.0.0.alpha.1

data/lib/occi/core/attribute.rb

@@ -0,0 +1,99 @@
+module Occi
+  module Core
+    module Attribute
+
+      attr_accessor :properties
+
+    end
+  end
+end
+
+class StringAttribute < String
+
+  attr_accessor :properties
+
+  def properties
+    self.properties ||= Occi::Core::Properties.new
+  end
+
+end
+
+class NumericAttribute
+
+  attr_accessor :properties
+
+  def properties
+    self.properties ||= Occi::Core::Properties.new :type => 'number'
+  end
+
+end
+
+class FalseClass
+
+  include Occi::Core::Attribute
+
+  def properties
+    self.properties ||= Occi::Core::Properties.new :type => 'boolean'
+  end
+
+end
+
+class TrueClass
+
+  include Occi::Core::Attribute
+
+  def properties
+    self.properties ||= Occi::Core::Properties.new :type => 'boolean'
+  end
+
+end
+
+#module Occi
+#  module Core
+#    class Attribute < Occi::Core::AttributeProperties
+#
+#      attr_accessor :_value
+#
+#      # @param [Hash] properties
+#      # @param [Hash] default
+#      def initialize(properties={})
+#        super(properties)
+#        case properties
+#          when Occi::Core::AttributeProperties
+#            self._value = properties._value if properties._value if properties.respond_to?('_value')
+#          else
+#            self._value = properties[:value] if properties[:value]
+#        end
+#      end
+#
+#      def _value=(value)
+#        raise "value #{value} can not be assigned as the attribute is not mutable" unless self._mutable if self._value
+#        case self._type
+#          when 'number'
+#            raise "value #{value} from class #{value.class.name} does not match attribute property type #{self._type}" unless value.kind_of?(Numeric)
+#          when 'boolean'
+#            raise "value #{value} from class #{value.class.name} does not match attribute property type #{self._type}" unless !!value == value
+#          when 'string'
+#            raise "value #{value} from class #{value.class.name} does not match attribute property type #{self._type}" unless value.kind_of?(String) || value.kind_of?(Occi::Core::Entity)
+#          else
+#            raise "property type #{self._type} is not one of the allowed types number, boolean or string"
+#        end
+#        raise "value #{value} does not match pattern #{self._pattern}" if value.to_s.scan(Regexp.new(self._pattern)).empty? unless value.kind_of?(Occi::Core::Entity)
+#        @_value = value
+#      end
+#
+#      def inspect
+#        self._value
+#      end
+#
+#      def to_s
+#        self._value
+#      end
+#
+#      def empty?
+#        self._value.nil?
+#      end
+#
+#    end
+#  end
+#end

data/lib/occi/core/attributes.rb

@@ -0,0 +1,172 @@
+module Occi
+  module Core
+    class Attributes < Hashie::Mash
+
+      attr_accessor :converted
+
+      include Occi::Helpers::Inspect
+
+      def converted?
+        @converted||=false
+      end
+
+      def [](key)
+        if key.to_s.include? '.'
+          key, string = key.to_s.split('.', 2)
+          attributes = super(key)
+          raise "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
+          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
+        end
+      end
+
+      def remove(attributes)
+        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)
+            end
+          end
+        end
+        self
+      end
+
+      def convert(attributes=Occi::Core::Attributes.new(self))
+        attributes.each_pair do |key, value|
+          next if attributes.key?(key[1..-1])
+          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 [Array] 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])
+          if self[key].kind_of? Occi::Core::Attributes
+            self[key].names.each_pair { |k, v| hash[key + '.' + k] = v unless v.blank? }
+          else
+            hash[key] = self[key]
+          end
+        end
+        hash
+      end
+
+      # @param [Hash] attributes
+      # @return [Occi::Core::Properties] parsed Properties
+      def self.parse(hash)
+        hash ||= {}
+        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
+          else
+            attributes[key] = self.parse attributes[key]
+          end
+        end
+        attributes
+      end
+
+      # @param [Hash] attributes key value pair of full attribute names with their corresponding values
+      # @return [Occi::Core::Properties]
+      def self.split(attributes)
+        attribute = Attributes.new
+        attributes.each do |name, value|
+          key, _, rest = name.partition('.')
+          if rest.empty?
+            attribute[key] = value
+          else
+            attribute.merge! Attributes.new(key => self.split(rest => value))
+          end
+        end
+        return attribute
+      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 = {}
+        self.each_pair do |key, value|
+          next if self.key?(key[1..-1])
+          case value
+            when Occi::Core::Attributes
+              hash[key] = value.as_json unless value.as_json.size == 0
+            else
+              hash[key] = value.as_json if value
+          end
+        end
+        hash
+      end
+
+    end
+
+  end
+end

data/lib/occi/core/categories.rb

@@ -0,0 +1,51 @@
+module Occi
+  module Core
+    class Categories < Set
+
+      include Occi::Helpers::Inspect
+
+      attr_accessor :model
+
+      def initialize(categories=[])
+        categories.collect! { |category| convert category } if categories
+        super categories
+      end
+
+      def <<(category)
+        super convert category
+      end
+
+      def join(separator)
+        self.to_a.join(separator)
+      end
+
+      # Returns a Set with all categories related to the specified category
+      #
+      # @param [Occi::Core::Category] category
+      # @return [Occi::Core::Categories]
+      def get_related_to(category)
+        self.class.new select { |cat| cat.related_to? category }
+      end
+
+      # @param [Occi::Model] model
+      # @return [Occi::Model]
+      def model=(model)
+        @model = model
+        collect! { |category| model.get_by_id category.to_s or category }
+      end
+
+      # @param [Hash] options
+      # @return [Hashie::Mash] json representation
+      def as_json(options={})
+        self.to_a.as_json
+      end
+
+      private
+
+      def convert(category)
+        (@model.get_by_id category if @model if category.kind_of? String) or category
+      end
+
+    end
+  end
+end

data/lib/occi/core/category.rb

@@ -0,0 +1,153 @@
+module Occi
+  module Core
+    class Category
+
+      include Occi::Helpers::Inspect
+
+      attr_accessor :scheme, :term, :title, :attributes, :model
+
+      def self.categories
+        self.mixins + self.actions << self.kind
+      end
+
+      # @param [String ] scheme
+      # @param [String] term
+      # @param [String] title
+      # @param [Hash] attributes
+      def initialize(scheme='http://schemas.ogf.org/occi/core#',
+          term='category',
+          title=nil,
+          attributes=Occi::Core::Attributes.new)
+        @scheme = scheme
+        @term = term
+        @title = title
+        case attributes
+          when Occi::Core::Attributes
+            @attributes = attributes
+          else
+            @attributes = Occi::Core::Attributes.parse attributes
+        end
+      end
+
+
+      # @param [String] scheme
+      # @param [String] term
+      # @param [Array] related
+      # @return [Class] ruby class with scheme as namespace, term as name and related kind as super class
+      def self.get_class(scheme, term, related=['http://schemas.ogf.org/occi/core#entity'])
+        related = related.to_a.flatten
+        scheme += '#' unless scheme.end_with? '#'
+
+        if related.first.to_s == 'http://schemas.ogf.org/occi/core#entity' or related.first.nil?
+          parent = Occi::Core::Entity
+        elsif related.first.kind_of? Occi::Core::Kind
+          parent = related.first.entity_type
+        elsif related.first.kind_of? Occi::Core::Mixin
+          parent = related.first.class
+        else
+          related_scheme, related_term = related.first.to_s.split '#'
+          parent = self.get_class related_scheme, related_term
+        end
+
+        uri = URI.parse(scheme)
+
+        namespace = if uri.host == 'schemas.ogf.org'
+                      uri.path.reverse.chomp('/').reverse.split('/')
+                    else
+                      uri.host.split('.').reverse + uri.path.reverse.chomp('/').reverse.split('/')
+                    end
+
+        namespace = namespace.inject(Object) do |mod, name|
+          if mod.constants.collect { |sym| sym.to_s }.include? name.capitalize
+            mod.const_get name.capitalize
+          else
+            mod.const_set name.capitalize, Module.new
+          end
+        end
+
+        class_name =  term.gsub('-', '_').capitalize
+        if namespace.const_defined? class_name
+          klass = namespace.const_get class_name
+          unless klass.ancestors.include? Occi::Core::Entity or klass.ancestors.include? Occi::Core::Category
+            raise "OCCI Kind with type identifier #{scheme + term} could not be created as the corresponding class #{klass.to_s} already exists and is not derived from Occi::Core::Entity"
+          end
+        else
+          klass = namespace.const_set class_name, Class.new(parent)
+          klass.kind = Occi::Core::Kind.new scheme, term, nil, {}, related unless parent.ancestors.include? Occi::Core::Category
+        end
+
+        klass
+      end
+
+      # @param [Occi::Model] model
+      def model=(model)
+        @related.model=model if @related
+      end
+
+      # @return [String] Type identifier of the category
+      def type_identifier
+        @scheme + @term
+      end
+
+      # check if category is related to another category
+      # a category is related to another category
+      # if it is included in @related or
+      # if it is the category itself
+      #
+      # @param [String, Category] category Related Category or its type identifier
+      # @return [true,false] true if category is related to category_id else false
+      def related_to?(category)
+        if @related
+          self.related.each do |cat|
+            return true if cat.to_s == category.to_s
+          end
+          return true if self.to_s == category.to_s
+        end
+        false
+      end
+
+      # @param [Hash] options
+      # @return [Hashie::Mash] json representation
+      def as_json(options={})
+        category = Hashie::Mash.new
+        category.scheme = @scheme if @scheme
+        category.term = @term if @term
+        category.title = @title if @title
+        category.attributes = @attributes if @attributes.any?
+        category
+      end
+
+      # @return [String] short text representation of the category
+      def to_string_short
+        @term + ';scheme=' + @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=' + @title.inspect if @title
+        string
+      end
+
+      # @return [String] text representation
+      def to_text
+        'Category: ' + self.to_string
+      end
+
+      # @return [Hash] hash containing the HTTP headers of the text/occi rendering
+      def to_header
+        {:Category => self.to_string}
+      end
+
+      # @return [NilClass] category itself does not have a location
+      def location
+        nil # not implemented
+      end
+
+      def to_s
+        self.type_identifier
+      end
+
+    end
+  end
+end

data/lib/occi/core/entities.rb

@@ -0,0 +1,47 @@
+module Occi
+  module Core
+    class Entities < Set
+
+      include Occi::Helpers::Inspect
+
+      attr_accessor :model
+
+      def initialize(entities=[])
+        entities.to_a.each { |entity| entity.model = @model } if @model
+        super entities
+      end
+
+      def join(separator)
+        self.to_a.join(separator)
+      end
+
+      def model=(model)
+        @model = model
+        each { |entity| entity.model=model }
+      end
+
+      def check
+        each { |entity| entity.check }
+      end
+
+      def create(*args)
+        entity = Occi::Core::Entity.new(*args)
+        entity.model = @model if @model
+        self << entity
+        entity
+      end
+
+      def <<(entity)
+        entity.model = @model if @model
+        super entity
+      end
+
+      # @param [Hash] options
+      # @return [Hashie::Mash] json representation
+      def as_json(options={ })
+        self.to_a.as_json
+      end
+
+    end
+  end
+end