occi 2.5.19 → 3.0.0.beta.0

data/lib/occi/core/entity.rb

@@ -1,72 +1,106 @@
-require 'rubygems'
-require 'uuidtools'
-require 'hashie/mash'
-require 'active_support/json'
-require 'occi/model'
-require 'occi/core/attributes'
-require 'occi/core/kind'
-require 'occi/core/attribute_properties'
-
-module OCCI
+module Occi
   module Core
     class Entity
 
-      attr_accessor :mixins, :attributes, :actions
-      attr_reader :kind
+      attr_accessor :mixins, :attributes, :actions, :id, :model, :kind
 
-      # @return [OCCI::Core::Kind] kind definition of Entity type
-      def self.kind_definition
-        kind = OCCI::Core::Kind.new('http://schemas.ogf.org/occi/core#', 'entity')
+      class << self
+        attr_accessor :kind
+        attr_reader :mixins, :actions
+      end
+
+      def self.mixins
+        Occi::Core::Mixins.new
+      end
+
+      @kind = Occi::Core::Kind.new('http://schemas.ogf.org/occi/core#', 'entity')
+
+      @kind.title = "entity"
+
+      @kind.attributes.occi!.core!.id = Occi::Core::AttributeProperties.new(
+          { :pattern => "[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}" })
+
+      @kind.attributes.occi!.core!.title = Occi::Core::AttributeProperties.new(
+          { :mutable => true })
 
-        kind.title = "Entity"
 
-        kind.attributes.occi!.core!.id!.Type     = "string"
-        kind.attributes.occi!.core!.id!.Pattern  = "[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}"
-        kind.attributes.occi!.core!.id!.Required = false
-        kind.attributes.occi!.core!.id!.Mutable  = false
+      # @return [String]
+      def self.type_identifier
+        self.kind.type_identifier
+      end
+
+      # @param [Array] args list of arguments
+      # @return [Object] new instance of this class
+      def self.new(*args)
+        if args.size > 0
+          type_identifier = args[0].to_s
+          related         = [self.kind]
+        else
+          type_identifier = self.kind.type_identifier
+          related         = nil
+        end
+        scheme, term = type_identifier.split '#'
 
-        kind.attributes.occi!.core!.title!.Type     = "string"
-        kind.attributes.occi!.core!.title!.Pattern  = ".*"
-        kind.attributes.occi!.core!.title!.Required = false
-        kind.attributes.occi!.core!.title!.Mutable  = true
+        klass = Occi::Core::Kind.get_class scheme, term, related
 
-        kind
+        object = klass.allocate
+        object.send :initialize, *args
+        object
       end
 
       # @param [String] kind
       # @param [String] mixins
-      # @param [OCCI::Core::Attributes] attributes
-      def initialize(kind, mixins=nil, attributes=nil, actions=nil)
-        @checked = false
-        raise "Kind #{kind} not of type String" unless kind.kind_of? String
-        @kind                        = kind
-        @mixins                      = mixins.to_a.flatten
-        @attributes                  = OCCI::Core::Attributes.new(attributes)
-        @attributes.occi!.core![:id] ||= UUIDTools::UUID.random_create.to_s
-        @actions                     = actions.to_a.flatten
+      # @param [Occi::Core::Attributes] attributes
+      # @param [Occi::Core::Actions] actions
+      # @return [Occi::Core::Entity]
+      def initialize(kind = self.kind, mixins=[], attributes={ }, actions=[])
+        @kind       = self.class.kind.clone
+        @mixins     = Occi::Core::Mixins.new mixins
+        @attributes = Occi::Core::Attributes.new attributes
+        @actions    = Occi::Core::Actions.new actions
+      end
+
+      # @return [Occi::Core::Kind]
+      def kind
+        @kind
+      end
+
+      # @param [Occi::Core::Kind,String] kind
+      # @return [Occi::Core::Kind]
+      def kind=(kind)
+        if kind.kind_of? String
+          scheme, term = kind.split '#'
+          kind         = Occi::Core::Category.get_class scheme, term
+        end
+        @kind = kind
       end
 
       # @param [Array] mixins
       def mixins=(mixins)
-        @checked=false
-        @mixins =mixins
+        @mixins = Occi::Core::Mixins.new mixins
       end
 
-      # @param [OCCI::Core::Attributes] attributes
+      # @param [Occi::Core::Attributes] attributes
       def attributes=(attributes)
-        @checked   =false
-        @attributes=attributes
+        @attributes = Occi::Core::Attributes.new attributes
+      end
+
+      # @param [Occi::Core::Actions] actions
+      def actions=(actions)
+        @actions = Occi::Core::Actions.new actions
       end
 
       # set id for entity
       # @param [UUIDTools::UUID] id
       def id=(id)
         @attributes.occi!.core!.id = id
+        @id                        = id
       end
 
       # @return [UUIDTools::UUID] id of the entity
       def id
-        @attributes.occi!.core!.id
+        @id ||= @attributes.occi.core.id if @attributes.occi.core if @attributes.occi
+        @id
       end
 
       # set title attribute for entity
@@ -77,20 +111,30 @@ module OCCI
 
       # @return [String] title attribute of entity
       def title
-        @attributes.occi!.core!.title
+        @attributes.occi.core.title if @attributes.occi.core if @attributes.occi
+      end
+
+      # @param [Occi::Model] model
+      # @return [Occi::Model]
+      def model=(model)
+        @model = model
+        @kind  = (model.get_by_id(@kind.type_identifier) || @kind)
+        @kind.entities << self
+        @mixins.model = model
+        @mixins.each { |mixin| mixin.entities << self }
+        @actions.model = model
       end
 
       # @return [String] location of the entity
       def location
-        '/' + @kind.split('#').last + '/' + @attributes.occi!.core!.id
+        kind.location + id.gsub('urn:uuid:', '') if id
       end
 
       # check attributes against their definitions and set defaults
-      # @param [OCCI::Model] model representation of the OCCI model to check the attributes against
-      def check(model)
-        raise "No kind defined" unless @kind
-        definitions = OCCI::Core::Attributes.new
-        definitions.merge!(model.get_by_id(@kind).attributes)
+      # @param [Occi::Model] model representation of the Occi model to check the attributes against
+      def check
+        raise "No model associated" unless @model
+        definitions = model.get_by_id(@kind.to_s).attributes
         @mixins.each do |mixin_id|
           mixin = model.get_by_id(mixin_id)
           next if mixin.nil?
@@ -100,64 +144,60 @@ module OCCI
         @attributes = Entity.check(@attributes, definitions) if definitions
       end
 
-      # @param [OCCI::Core::Attributes] attributes
-      # @param [OCCI::Core::AttributeProperties] definitions
-      # @return [OCCI::Core::Attributes] attributes with their defaults set
-      def self.check(attributes, definitions)
-        attributes = OCCI::Core::Attributes.new(attributes)
+      # @param [Occi::Core::Attributes] attributes
+      # @param [Occi::Core::Attributes] definitions
+      # @param [true,false] set_defaults
+      # @return [Occi::Core::Attributes] attributes with their defaults set
+      def self.check(attributes, definitions, set_defaults=false)
+        attributes = Occi::Core::Attributes.new(attributes)
         definitions.each_key do |key|
-          properties = definitions[key]
-          value      = attributes[key] ||= properties.Default
-          if properties.key? :Type
-            raise "required attribute #{key} not found" if value.nil? && properties.Required
-            next if value.nil? && !properties.Required
-            case properties.Type
+          if definitions[key].kind_of? Occi::Core::Attributes
+            attributes[key] = check(attributes[key], definitions[key])
+          else
+            properties = definitions[key]
+            value      = attributes[key]
+            value ||= properties.default if set_defaults or properties.required
+            raise "required attribute #{key} not found" if value.nil? && properties.required
+            next if value.nil? and not properties.required
+            case properties.type
               when 'number'
-                raise "attribute #{key} value #{value} from class #{value.class.name} does not match attribute property type #{properties.Type}" unless value.kind_of?(Numeric)
-                raise "attribute #{key} with value #{value} not in range #{properties.Minimum}-#{properties.Maximum}" unless (properties.Minimum..properties.Maximum) === value if properties.Minimum && properties.Maximum
+                raise "attribute #{key} value #{value} from class #{value.class.name} does not match attribute property type #{properties.type}" unless value.kind_of?(Numeric)
               when 'boolean'
-                raise "attribute #{key} value #{value} from class #{value.class.name} does not match attribute property type #{properties.Type}" unless !!value == value
+                raise "attribute #{key} value #{value} from class #{value.class.name} does not match attribute property type #{properties.type}" unless !!value == value
+              when 'string'
+                raise "attribute #{key} with value #{value} from class #{value.class.name} does not match attribute property type #{properties.type}" unless value.kind_of?(String)
               else
-                raise "attribute #{key} with value #{value} from class #{value.class.name} does not match attribute property type #{properties.Type}" unless value.kind_of?(String)
-                raise "attribute #{key} with length #{value.length} not in range #{properties.Minimum}-#{properties.Maximum}" unless (properties.Minimum..properties.Maximum) === value.length if properties.Minimum && properties.Maximum
+                raise "property type #{properties.type} is not one of the allowed types number, boolean or string"
             end
-            raise "attribute #{key} with value #{value} does not match pattern #{properties.Pattern}" if value.to_s.scan(Regexp.new(properties.Pattern)).empty? if properties.Pattern
+            Occi::Log.warn "attribute #{key} with value #{value} does not match pattern #{properties.pattern}" if value.to_s.scan(Regexp.new(properties.pattern)).empty? if properties.pattern
             attributes[key] = value
-          else
-            attributes[key] = check(value, definitions[key])
           end
         end
-        attributes.delete_if { |_, v| v.nil? } # remove empty attributes
-        @checked = true
+        attributes.delete_if { |_, v| v.empty? } # remove empty attributes
         attributes
       end
 
-      # @return [true,false]
-      def checked?
-        @checked && @attributes.checked?
-      end
-
       # @param [Hash] options
       # @return [Hashie::Mash] json representation
       def as_json(options={ })
         entity = Hashie::Mash.new
-        entity.kind = @kind if @kind
-        entity.mixins = @mixins if @mixins.any?
+        entity.kind = @kind.to_s if @kind
+        entity.mixins = @mixins.join(' ').split(' ') if @mixins.any?
         entity.actions = @actions if @actions.any?
         entity.attributes = @attributes if @attributes.any?
+        entity.id = id if id
         entity
       end
 
       # @return [String] text representation
       def to_text
-        scheme, term = self.kind.split('#')
-        text         = 'Category: ' + term + ';scheme=' + scheme.inspect + ';class="kind"' + "\n"
+        text = 'Category: ' + self.kind.term + ';scheme=' + self.kind.scheme.inspect + ';class="kind"' + "\n"
         @mixins.each do |mixin|
-          scheme, term = mixin.split('#')
+          scheme, term = mixin.to_s.split('#')
+          scheme << '#'
           text << 'Category: ' + term + ';scheme=' + scheme.inspect + ';class="mixin"' + "\n"
         end
         @attributes.combine.each_pair do |name, value|
-          name = name.inspect
           value = value.inspect
           text << 'X-OCCI-Attribute: ' + name + '=' + value + "\n"
         end
@@ -168,17 +208,17 @@ module OCCI
         text
       end
 
+      # @return [Hash] hash containing the HTTP headers of the text/occi rendering
       def to_header
-        scheme, term      = self.kind.split('#')
-        header            = Hashie::Mash.new
-        header['Category'] = term + ';scheme=' + scheme.inspect + ';class="kind"'
+        header             = Hashie::Mash.new
+        header['Category'] = self.kind.term + ';scheme=' + self.kind.scheme.inspect + ';class="kind"'
         @mixins.each do |mixin|
-          scheme, term      = mixin.split('#')
+          scheme, term = mixin.to_s.split('#')
+          scheme << '#'
           header['Category'] += ',' + term + ';scheme=' + scheme.inspect + ';class="mixin"'
         end
         attributes = []
         @attributes.combine.each_pair do |name, value|
-          name = name.inspect
           attributes << name + '=' + value.inspect
         end
         header['X-OCCI-Attribute'] = attributes.join(',') if attributes.any?
@@ -187,18 +227,19 @@ module OCCI
           _, term = action.split('#')
           links << self.location + '?action=' + term + '>;rel=' + action.inspect
         end
-        header['Link'] = links.join(',') if links.any?
         header
       end
 
-      def to_s
-        self.location
-      end
-
+      # @return [String] json representation
       def inspect
         JSON.pretty_generate(JSON.parse(to_json))
       end
 
+      # @return [String] string representation of entity is its location
+      def to_s
+        self.location
+      end
+
     end
   end
 end

data/lib/occi/core/kind.rb

@@ -1,63 +1,56 @@
-require 'active_support/json'
-require 'occi/core/category'
-require 'occi/core/action'
-require 'occi/core/attribute_properties'
-
-module OCCI
+module Occi
   module Core
-    class Kind < OCCI::Core::Category
+    class Kind < Occi::Core::Category
 
-      attr_accessor :entities, :related, :actions
+      attr_accessor :entities, :related, :actions, :location
 
       # @param [String ] scheme
       # @param [String] term
       # @param [String] title
-      # @param [OCCI::Core::AttributeProperties] attributes
+      # @param [Hash] attributes
       # @param [Array] related
       # @param [Array] actions
-      def initialize(scheme, term, title=nil, attributes=nil, related=nil, actions=nil)
-        @entities = []
-        @related  = related.to_a
-        @actions  = actions.to_a
+      def initialize(scheme='http://schemas.ogf.org/occi/core#',
+          term='kind',
+          title=nil,
+          attributes=Occi::Core::Attributes.new,
+          related=Occi::Core::Categories.new,
+          actions=Occi::Core::Actions.new,
+          location=nil)
         super(scheme, term, title, attributes)
+        @related  = Occi::Core::Related.new(related)
+        @actions  = Occi::Core::Actions.new(actions)
+        @entities = Occi::Core::Entities.new
+        location.blank? ? @location = '/' + term + '/' : @location = location
       end
 
-      # @return [String] name of the OCCI core class the entity is related to
       def entity_type
-        case type_identifier
-          when "http://schemas.ogf.org/occi/core#resource"
-            return OCCI::Core::Resource
-          when "http://schemas.ogf.org/occi/core#link"
-            return OCCI::Core::Link
-          else
-            raise "no model back reference provided for kind #{self.typ_identifier}" unless @model
-            @model.get_by_id(self.related.first).entity_type unless self.term == 'entity'
-        end
+        self.class.get_class @scheme, @term, @related
       end
 
-      # @return [String] string containing location URI of kind
       def location
-        '/' + @term + '/'
+        @location.clone
       end
 
       # @param [Hash] options
       # @return [Hashie::Mash] json representation
       def as_json(options={ })
         kind = Hashie::Mash.new
-        kind.related = @related if @related.any?
-        kind.actions = @actions if @actions.any?
+        kind.related = @related.join(' ').split(' ') if @related.any?
+        kind.actions = @actions.join(' ').split(' ') if @actions.any?
+        kind.location = @location if @location
         kind.merge! super
         kind
       end
 
-      # @return [String] text representation
-      def to_text
-        text = super
-        text << ';rel=' + @related.join(' ').inspect if @related.any?
-        text << ';location=' + self.location.inspect
-        text << ';attributes=' + @attributes.combine.join(' ').inspect if @attributes.any?
-        text << ';actions=' + @actions.join(' ').inspect if @actions.any?
-        text
+      # @return [String] string representation of the kind
+      def to_string
+        string = super
+        string << ';rel=' + @related.join(' ').inspect if @related.any?
+        string << ';location=' + self.location.inspect
+        string << ';attributes=' + @attributes.combine.keys.join(' ').inspect if @attributes.any?
+        string << ';actions=' + @actions.join(' ').inspect if @actions.any?
+        string
       end
 
     end

data/lib/occi/core/kinds.rb

@@ -0,0 +1,22 @@
+module Occi
+  module Core
+    class Kinds < Occi::Core::Categories
+
+      private
+
+      def convert(category)
+        category = super category
+
+        if category.kind_of? String
+          scheme, term = category.split '#'
+          scheme       += '#'
+
+          klass    = Occi::Core::Category.get_class scheme, term, [Occi::Core::Kind.new]
+          category = klass.kind
+        end
+        category
+      end
+
+    end
+  end
+end

data/lib/occi/core/link.rb

@@ -1,45 +1,36 @@
-require 'hashie/mash'
-require 'occi/core/entity'
-require 'occi/core/kind'
-
-module OCCI
+module Occi
   module Core
-    class Link < Entity
+    class Link < Occi::Core::Entity
 
       attr_accessor :rel, :source, :target
 
-      # @return [OCCI::Core::Kind] kind definition of Link type
-      def self.kind_definition
-        kind = OCCI::Core::Kind.new('http://schemas.ogf.org/occi/core#', 'link')
-
-        kind.related = %w{http://schemas.ogf.org/occi/core#entity}
-        kind.title   = "Link"
+      @kind = Occi::Core::Kind.new('http://schemas.ogf.org/occi/core#', 'link')
 
-        kind.attributes.occi!.core!.target!.Type     = "string"
-        kind.attributes.occi!.core!.target!.Pattern  = ".*"
-        kind.attributes.occi!.core!.target!.Required = false
-        kind.attributes.occi!.core!.target!.Mutable  = true
+      @kind.related << Occi::Core::Entity.kind
+      @kind.title = "link"
 
-        kind.attributes.occi!.core!.source!.Type     = "string"
-        kind.attributes.occi!.core!.source!.Pattern  = ".*"
-        kind.attributes.occi!.core!.source!.Required = false
-        kind.attributes.occi!.core!.source!.Mutable  = true
+      @kind.attributes.occi!.core!.target = Occi::Core::AttributeProperties.new(
+          { :mutable => true })
 
-        kind
-      end
+      @kind.attributes.occi!.core!.source = Occi::Core::AttributeProperties.new(
+          { :mutable => true })
 
       # @param [String] kind
       # @param [String] mixins
       # @param [Occi::Core::Attributes] attributes
       # @param [Array] actions
       # @param [String] rel
-      # @param [String,OCCI::Core::Entity] target
-      # @param [String,OCCI::Core::Entity] source
-      def initialize(kind, mixins=[], attributes={ }, actions=[], rel=nil, target=nil, source=nil)
-        super(kind,mixins,attributes,actions)
-        @rel = rel if rel
-        self.source = source if source
-        self.target = target
+      # @param [String,Occi::Core::Entity] target
+      # @param [String,Occi::Core::Entity] source
+      def initialize(kind=self.kind, mixins=[], attributes={ }, actions=[], rel=nil, target=nil, source=nil)
+        super(kind, mixins, attributes, actions)
+        if rel.kind_of? String
+          scheme, term = rel.to_s.split('#')
+          @rel         = Occi::Core::Category.get_class(scheme, term).kind if scheme && term
+        end
+        @rel ||= Occi::Core::Resource.kind
+        @source = source if source
+        @target = target
       end
 
       # @return [String] target attribute of the link
@@ -66,7 +57,7 @@ module OCCI
         @source = resource
       end
 
-      # @param [OCCI::Model] model
+      # @param [Occi::Model] model
       def check(model)
         raise "rel must be provided" unless @rel
         super(model)
@@ -76,21 +67,33 @@ module OCCI
       # @return [Hashie::Mash] json representation
       def as_json(options={ })
         link = super
-        link.rel = @rel if @rel
-        link.source = self.source.to_s if self.source.to_s
+        link.rel = @rel.to_s if @rel
+        link.source = self.source.to_s if self.source.kind_of? String if self.source
         link.target = self.target.to_s if self.target
         link
       end
 
       # @return [String] text representation of link reference
-      def to_reference_text
-        OCCI::Log.debug "Test"
-        text = '<' + target + '>'
-        text << ';rel=' + @rel.inspect
-        text << ';self=' + self.location
-        text << ';category=' + @kind
-        @attributes.combine.each_pair { |name, value| text << name + '=' + value + ';' }
-        text
+      def to_string
+        string = '<' + self.target.to_s + '>'
+        string << ';rel=' + @rel.to_s.inspect
+        string << ';self=' + self.location.inspect if self.location
+        categories = [@kind] + @mixins.join(',').split(',')
+        string << ';category=' + categories.join(' ').inspect
+        string << ';'
+        @attributes.combine.each_pair do |name, value|
+          value = value.inspect
+          string << name + '=' + value + ';'
+        end
+        string << 'occi.core.target=' + self.target.to_s.inspect
+        string << 'occi.core.source=' + self.source.to_s.inspect if self.source.kind_of? String if self.source
+
+        string
+      end
+
+      # @return [String] text representation of link
+      def to_text_link
+        'Link: ' + self.to_string
       end
 
     end