occi 2.5.19 → 3.0.0.beta.0

data/lib/occi/core/attribute_properties.rb

@@ -1,99 +1,48 @@
 require 'hashie/mash'
 
-module OCCI
+module Occi
   module Core
     class AttributeProperties < Hashie::Mash
 
-      # @param [Hashie::Mash] attributes
+      # @param [Hash] properties
       # @param [Hash] default
-      def initialize(attributes = nil, default = nil)
-        if [:Type, :Required, :Mutable, :Pattern, :Default, :Minimum, :Maximum, :Description].any? { |k| attributes.key?(k.capitalize) }
-          attributes[:Type]   ||= "string"
-          attributes[:Required] ||= false
-          attributes[:Mutable]  ||= false
-          attributes[:Pattern]  ||= ".*"
-        end if attributes
-        super(attributes, default)
+      def initialize(properties=nil,default=nil)
+        properties ||= {}
+        properties[:type] ||= 'string'
+        properties[:required] ||= false
+        properties[:mutable]  ||= false
+        properties[:pattern]  ||= '.*'
+        super properties, default
       end
 
-      # @return [Array] list of full attribute names
-      def combine
-        array = []
-        self.each_key do |key|
-          if self[key].key?('Type') || self[key].key?('type')
-            array << key
-          else
-            attribute = self[key]
-            attribute.combine.each { |attr| array << key + '.' + attr }
+      # @param [Hash] properties
+      # @return [Occi::Core::Attributes] parsed Attribute Properties
+      def self.parse(properties)
+        properties ||= Hashie::Mash.new
+        if [:Type, :Required, :Mutable, :Default, :Description, :Pattern, :type, :required, :mutable, :default, :description, :pattern].any? { |k| properties.key?(k) and not properties[k].kind_of? Hash }
+          properties[:type]     ||= properties[:Type] ||= "string"
+          properties[:required] ||= properties[:Required] ||= false
+          properties[:mutable]  ||= properties[:Mutable] ||= false
+          properties[:default] = properties[:Default] if properties[:Default]
+          properties[:description] = properties[:Description] if properties[:Description]
+          properties[:pattern] ||= properties[:Pattern] ||= ".*"
+          properties.delete :Type
+          properties.delete :Required
+          properties.delete :Mutable
+          properties.delete :Default
+          properties.delete :Description
+          properties.delete :Pattern
+          return self.new properties
+        else
+          attributes = Occi::Core::Attributes.new
+          properties.each_key do |key|
+            attributes[key] = self.parse properties[key]
           end
-        end
-        array
-      end
-
-
-      # @return [Hash] key value pairs of attribute names with their defaults set
-      def combine_with_defaults
-        hash = { }
-        self.each_key do |key|
-          if self[key].include?('Type') || self[key].include?('type')
-            hash[key] = self[key]['Default']
-          else
-            self[key].combine_with_defaults.each { |k, v| hash[key + '.' + k] = v }
-          end
-        end
-        hash
-      end
-
-      def convert_value(val, duping=false) #:nodoc:
-        case val
-          when self.class
-            val.dup
-          when ::Hash
-            val = val.dup if duping
-            self.class.subkey_class.new(val)
-          when Array
-            val.collect { |e| convert_value(e) }
-          else
-            val
-        end
-      end
-
-      # Overrides method of hashie mash to check if one of the attribute properties has been set
-      def method_missing(method_name, *args, &blk)
-        return self.[](method_name, &blk) if key?(method_name)
-        match = method_name.to_s.match(/(.*?)([?=!]?)$/)
-        case match[2]
-          when "="
-            key = match[1]
-            self[key] = args.first
-            if %w|Type Required Mutable Pattern Default Minimum Maximum Description|.any? { |k| key.to_s.capitalize == k }
-              self["Type"] = "string" unless key?("Type") || key?("type")
-              self["Required"] = false unless key?("Required") || key?("required")
-              self["Mutable"] = false unless key?("Mutable") || key?("mutable")
-              self["Pattern"] = ".*" unless key?("Pattern") || key?("pattern")
-            end
-          when "?"
-            !!self[match[1]]
-          when "!"
-            initializing_reader(match[1])
-          else
-            default(method_name, *args, &blk)
-        end
-      end
-
-      # Sets an attribute in the Mash. Key will be converted to
-      # a string before it is set, and Hashes will be converted
-      # into Mashes for nesting purposes.
-      def []=(key, value) #:nodoc:
-        regular_writer(convert_key(key), convert_value(value))
-        if %w|Type Required Mutable Pattern Default Minimum Maximum Description|.any? { |k| key.to_s.capitalize == k }
-          self["Type"] = "string" unless key?("Type") || key?("type")
-          self["Required"] = false unless key?("Required") || key?("required")
-          self["Mutable"] = false unless key?("Mutable") || key?("mutable")
-          self["Pattern"] = ".*" unless key?("Pattern") || key?("pattern")
+          return attributes
         end
       end
 
+      # @return [String] json representation
       def inspect
         JSON.pretty_generate(JSON.parse(to_json))
       end

data/lib/occi/core/attributes.rb

@@ -1,14 +1,14 @@
 require 'hashie/mash'
 
-module OCCI
+module Occi
   module Core
     class Attributes < Hashie::Mash
 
-    # @return [Array] key value pair of full attribute names with their corresponding values
-    def combine
+      # @return [Array] key value pair of full attribute names with their corresponding values
+      def combine
         hash = { }
         self.each_key do |key|
-          if self[key].kind_of? OCCI::Core::Attributes
+          if self[key].kind_of? Occi::Core::Attributes
             self[key].combine.each_pair { |k, v| hash[key + '.' + k] = v }
           else
             hash[key] = self[key]
@@ -17,12 +17,34 @@ module OCCI
         hash
       end
 
-    # @param [Hash] attributes key value pair of full attribute names with their corresponding values
-    # @return [OCCI::Core::Attributes]
-    def self.split(attributes)
+      def convert_value(val, duping=false) #:nodoc:
+        case val
+          when self.class
+            val.dup
+          when Hashie::Mash
+            val = val.dup if duping
+            val
+          when ::Hash
+            val = val.dup if duping
+            self.class.subkey_class.new.merge(val)
+          when Array
+            val.collect { |e| convert_value(e) }
+          else
+            val
+        end
+      end
+
+      # @return [String] json representation
+      def inspect
+        JSON.pretty_generate(JSON.parse(to_json))
+      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|
-          puts name
+        attributes.each do |name, value|
+          Occi::Log.debug "Attribute named #{name}"
           key, _, rest = name.partition('.')
           if rest.empty?
             attribute[key] = value
@@ -35,9 +57,5 @@ module OCCI
 
     end
 
-    def inspect
-      JSON.pretty_generate(JSON.parse(to_json))
-    end
-
   end
-end
+end

data/lib/occi/core/categories.rb

@@ -0,0 +1,46 @@
+module Occi
+  module Core
+    class Categories < Set
+
+      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
+
+      # @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
+
+      # @return [String] json representation
+      def inspect
+        JSON.pretty_generate(JSON.parse(to_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

@@ -1,22 +1,76 @@
-require 'active_support/json'
-require 'active_support/inflector'
-require 'hashie/mash'
-
-module OCCI
+module Occi
   module Core
     class Category
 
-      attr_accessor :model, :scheme, :term, :title, :attributes
+      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 [OCCI::Core::AttributeProperties] attributes
-      def initialize(scheme, term, title=nil, attributes=nil)
+      # @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
-        @attributes = OCCI::Core::AttributeProperties.new(attributes)
+        @attributes = Occi::Core::AttributeProperties.parse attributes
+      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::Category
+          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.classify
+            mod.const_get name.classify
+          else
+            mod.const_set name.classify, Module.new
+          end
+        end
+
+        if namespace.const_defined? term.classify
+          klass = namespace.const_get term.classify
+          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 term.classify, 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
@@ -25,12 +79,12 @@ module OCCI
       end
 
       # check if category is related to another category
-      # @param [String] category_id Type identifier of a related category
+      # @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_id)
-        self.related.each do |rel_id|
-          return true if rel_id == category_id || @model.get_by_id(rel_id).related_to?(category_id)
-        end if self.class.method_defined? 'related'
+      def related_to?(category)
+        self.related.each do |cat|
+          return true if cat.to_s == category.to_s
+        end if @related
         false
       end
 
@@ -45,22 +99,42 @@ module OCCI
         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
-        text = @term + ';scheme=' + @scheme.inspect + ';class=' + self.class.name.demodulize.downcase.inspect
-        text << ';title=' + @title.inspect if @title
-        text
+        'Category: ' + self.to_string
       end
 
+      # @return [Hash] hash containing the HTTP headers of the text/occi rendering
       def to_header
-        header = Hashie::Mash.new
-        header[:Category] = self.to_text
+        { :Category => self.to_string }
       end
 
+      # @return [String] json representation
       def inspect
         JSON.pretty_generate(JSON.parse(to_json))
       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
+end

data/lib/occi/core/entities.rb

@@ -0,0 +1,50 @@
+module Occi
+  module Core
+    class Entities < Set
+
+      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
+
+      # @return [String] json representation
+      def inspect
+        JSON.pretty_generate(JSON.parse(to_json))
+      end
+
+    end
+  end
+end