occi-core 4.1.3 → 4.2.0

data/lib/occi/parser/text.rb

@@ -1,250 +1,211 @@
+Dir[File.join(File.dirname(__FILE__), 'text', '*.rb')].each { |file| require file.gsub('.rb', '') }
+
 module Occi
   module Parser
     module Text
 
-      # Regular expressions
-      REGEXP_QUOTED_STRING = /([^"\\]|\\.)*/
-      REGEXP_LOALPHA = /[a-z]/
-      REGEXP_DIGIT = /[0-9]/
-      REGEXP_INT = /#{REGEXP_DIGIT}+/
-      REGEXP_FLOAT = /#{REGEXP_INT}\.#{REGEXP_INT}/
-      REGEXP_NUMBER = /#{REGEXP_FLOAT}|#{REGEXP_INT}/
-      REGEXP_BOOL = /true|false/
-
-      # Regular expressions for OCCI
-      if Occi::Settings.compatibility
-        # Compatibility with terms starting with a number
-        REGEXP_TERM = /(#{REGEXP_LOALPHA}|#{REGEXP_DIGIT})(#{REGEXP_LOALPHA}|#{REGEXP_DIGIT}|-|_)*/
-      else
-        REGEXP_TERM = /#{REGEXP_LOALPHA}(#{REGEXP_LOALPHA}|#{REGEXP_DIGIT}|-|_)*/
-      end
-      REGEXP_SCHEME = /#{URI::ABS_URI_REF}#/
-      REGEXP_TYPE_IDENTIFIER = /#{REGEXP_SCHEME}#{REGEXP_TERM}/
-      REGEXP_CLASS = /action|mixin|kind/
-
-      REGEXP_ATTR_COMPONENT = /#{REGEXP_LOALPHA}(#{REGEXP_LOALPHA}|#{REGEXP_DIGIT}|-|_)*/
-      REGEXP_ATTRIBUTE_NAME = /#{REGEXP_ATTR_COMPONENT}(\.#{REGEXP_ATTR_COMPONENT})*/
-      REGEXP_ATTRIBUTE_PROPERTY = /immutable|required/
-      REGEXP_ATTRIBUTE_DEF = /(#{REGEXP_ATTRIBUTE_NAME})(\{#{REGEXP_ATTRIBUTE_PROPERTY}(\s+#{REGEXP_ATTRIBUTE_PROPERTY})*\})?/
-      REGEXP_ATTRIBUTE_LIST = /#{REGEXP_ATTRIBUTE_DEF}(\s+#{REGEXP_ATTRIBUTE_DEF})*/
-      REGEXP_ATTRIBUTE_REPR = /#{REGEXP_ATTRIBUTE_NAME}=("#{REGEXP_QUOTED_STRING}"|#{REGEXP_NUMBER}|#{REGEXP_BOOL})/
-
-      REGEXP_ACTION = /#{REGEXP_TYPE_IDENTIFIER}/
-      REGEXP_ACTION_LIST = /#{REGEXP_ACTION}(\s+#{REGEXP_ACTION})*/
-
-      REGEXP_RESOURCE_TYPE = /#{REGEXP_TYPE_IDENTIFIER}(\s+#{REGEXP_TYPE_IDENTIFIER})*/
-      REGEXP_LINK_INSTANCE = /#{URI::URI_REF}/
-      REGEXP_LINK_TYPE = /#{REGEXP_TYPE_IDENTIFIER}(\s+#{REGEXP_TYPE_IDENTIFIER})*/
-
-      # Regular expression for OCCI Categories
-      if Occi::Settings.compatibility
-        REGEXP_CATEGORY = "Category:\\s*(?<term>#{REGEXP_TERM})" << # term (mandatory)
-            ";\\s*scheme=\"(?<scheme>#{REGEXP_SCHEME})#{REGEXP_TERM}?\"" << # scheme (mandatory)
-            ";\\s*class=\"(?<class>#{REGEXP_CLASS})\"" << # class (mandatory)
-            "(;\\s*title=\"(?<title>#{REGEXP_QUOTED_STRING})\")?" << # title (optional)
-            "(;\\s*rel=\"(?<rel>#{REGEXP_TYPE_IDENTIFIER})\")?"<< # rel (optional)
-            "(;\\s*location=\"(?<location>#{URI::URI_REF})\")?" << # location (optional)
-            "(;\\s*attributes=\"(?<attributes>#{REGEXP_ATTRIBUTE_LIST})\")?" << # attributes (optional)
-            "(;\\s*actions=\"(?<actions>#{REGEXP_ACTION_LIST})\")?" << # actions (optional)
-            ';?' # additional semicolon at the end (not specified, for interoperability)
-      else
-        REGEXP_CATEGORY = "Category:\\s*(?<term>#{REGEXP_TERM})" << # term (mandatory)
-            ";\\s*scheme=\"(?<scheme>#{REGEXP_SCHEME})\"" << # scheme (mandatory)
-            ";\\s*class=\"(?<class>#{REGEXP_CLASS})\"" << # class (mandatory)
-            "(;\\s*title=\"(?<title>#{REGEXP_QUOTED_STRING})\")?" << # title (optional)
-            "(;\\s*rel=\"(?<rel>#{REGEXP_TYPE_IDENTIFIER})\")?"<< # rel (optional)
-            "(;\\s*location=\"(?<location>#{URI::URI_REF})\")?" << # location (optional)
-            "(;\\s*attributes=\"(?<attributes>#{REGEXP_ATTRIBUTE_LIST})\")?" << # attributes (optional)
-            "(;\\s*actions=\"(?<actions>#{REGEXP_ACTION_LIST})\")?" << # actions (optional)
-            ';?' # additional semicolon at the end (not specified, for interoperability)
-      end
-
-      # Regular expression for OCCI Link Instance References
-      if Occi::Settings.compatibility
-        REGEXP_LINK = "Link:\\s*\\<(?<uri>#{URI::URI_REF})\\>" << # uri (mandatory)
-            ";\\s*rel=\"(?<rel>#{REGEXP_RESOURCE_TYPE})\"" << # rel (mandatory)
-            "(;\\s*self=\"(?<self>#{REGEXP_LINK_INSTANCE})\")?" << # self (optional)
-            "(;\\s*category=\"(?<category>(;?\\s*(#{REGEXP_LINK_TYPE}))+)\")?" << # category (optional)
-            "(?<attributes>(;?\\s*(#{REGEXP_ATTRIBUTE_REPR}))*)" << # attributes (optional)
-            ';?' # additional semicolon at the end (not specified, for interoperability)
-      else
-        REGEXP_LINK = "Link:\\s*\\<(?<uri>#{URI::URI_REF})\\>" << # uri (mandatory)
-            ";\\s*rel=\"(?<rel>#{REGEXP_RESOURCE_TYPE})\"" << # rel (mandatory)
-            "(;\\s*self=\"(?<self>#{REGEXP_LINK_INSTANCE})\")?" << # self (optional)
-            "(;\\s*category=\"(?<category>(;?\\s*(#{REGEXP_LINK_TYPE}))+)\")?" << # category (optional)
-            "(?<attributes>(;\\s*(#{REGEXP_ATTRIBUTE_REPR}))*)" << # attributes (optional)
-            ';?' # additional semicolon at the end (not specified, for interoperability)
-      end
+      class << self
 
-      # Regular expression for OCCI Entity Attributes
-      REGEXP_ATTRIBUTE = "X-OCCI-Attribute:\\s*(?<name>#{REGEXP_ATTRIBUTE_NAME})=(\"(?<string>#{REGEXP_QUOTED_STRING})\"|(?<number>#{REGEXP_NUMBER})|(?<bool>#{REGEXP_BOOL}))" <<
-          ';?' # additional semicolon at the end (not specified, for interoperability)
+        include Occi::Parser::Text::Constants
 
-      # Regular expression for OCCI Location
-      REGEXP_LOCATION = "X-OCCI-Location:\\s*(?<location>#{URI::URI_REF})" <<
-          ';?' # additional semicolon at the end (not specified, for interoperability)
+        def categories(lines)
+          Occi::Log.debug "[#{self}] Parsing through Occi::Parser::Text.categories"
+          collection = Occi::Collection.new
 
+          block = Proc.new { |line|
+            line.strip!
+            category = category(line) if line.start_with? 'Category:'
+            collection << category if category.kind_of? Occi::Core::Category
+          }
 
-      def self.categories(lines)
-        collection = Occi::Collection.new
-        lines.each do |line|
-          line.strip!
-          category = self.category(line) if line.start_with? 'Category:'
-          collection << category if category.kind_of? Occi::Core::Category
+          lines.respond_to?(:each) ? lines.each(&block) : lines.each_line(&block)
+          collection
         end
-        collection
-      end
 
-      def self.resource(lines)
-        collection = Occi::Collection.new
-        resource = Occi::Core::Resource.new
-        lines.each do |line|
-          line.strip!
-          case line
+        def resource(lines)
+          Occi::Log.debug "[#{self}] Parsing through Occi::Parser::Text.resource"
+          collection = Occi::Collection.new
+          resource = Occi::Core::Resource.new
+          resource.id = nil
+          links = []
+
+          block = Proc.new { |line|
+            line.strip!
+            case line
             when /^Category:/
-              category = self.category(line)
-              resource.kind = category if category.kind_of? Occi::Core::Kind
+              category = category(line)
+
+              if category.kind_of? Occi::Core::Kind
+                resource = Occi::Core::Entity.new(category.type_identifier)
+                resource.kind = category
+              end
               resource.mixins << category if category.kind_of? Occi::Core::Mixin
             when /^X-OCCI-Attribute:/
-              resource.attributes.merge! self.attribute(line)
+              resource.attributes.merge! attribute(line)
             when /^Link:/
-              link = self.link_string(line, resource)
+              link = link_string(line, resource)
               resource.links << link
-              collection << link
+              links << link
+            end
+          }
+          lines.respond_to?(:each) ? lines.each(&block) : lines.each_line(&block)
+
+          if resource.kind_of?(Occi::Core::Resource) && !resource.empty?
+            collection << resource
+            links.each { |link| collection << link }
           end
+
+          collection
         end
-        collection << resource if resource.kind_of? Occi::Core::Resource
-        collection
-      end
 
-      def self.link(lines)
-        collection = Occi::Collection.new
-        link = Occi::Core::Link.new
-        lines.each do |line|
-          line.strip!
-          case line
+        def link(lines)
+          Occi::Log.debug "[#{self}] Parsing through Occi::Parser::Text.link"
+          collection = Occi::Collection.new
+          link = Occi::Core::Link.new
+          link.id = nil
+
+          block = Proc.new { |line|
+            line.strip!
+            case line
             when /^Category:/
-              category = self.category(line)
+              category = category(line)
               link.kind = category if category.kind_of? Occi::Core::Kind
               link.mixins << category if category.kind_of? Occi::Core::Mixin
             when /^X-OCCI-Attribute:/
-              link.attributes.merge! self.attribute(line)
-          end
+              link.attributes.merge! attribute(line)
+            end
+          }
+          lines.respond_to?(:each) ? lines.each(&block) : lines.each_line(&block)
+
+          collection << link if link.kind_of?(Occi::Core::Link) && !link.empty?
+          collection
         end
-        collection << link if link.kind_of? Occi::Core::Link
-        collection
-      end
 
-      def self.locations(lines)
-        locations = []
-        lines.each do |line|
-          line.strip!
-          locations << self.location(line) if line.start_with? 'X-OCCI-Location:'
+        def locations(lines)
+          Occi::Log.debug "[#{self}] Parsing through Occi::Parser::Text.locations"
+          locations = []
+
+          block = Proc.new { |line|
+            line.strip!
+            locations << location(line) if line.start_with? 'X-OCCI-Location:'
+          }
+          lines.respond_to?(:each) ? lines.each(&block) : lines.each_line(&block)
+
+          locations
         end
-        locations
-      end
 
-      private
-
-      def self.category(string)
-        # create regular expression from regexp string
-        regexp = Regexp.new(REGEXP_CATEGORY)
-        # match string to regular expression
-        match = regexp.match string
-
-        raise "could not match #{string}" unless match
-
-        term = match[:term]
-        scheme = match[:scheme]
-        title = match[:title]
-        related = match[:rel].to_s.split
-        attributes = Occi::Core::Attributes.new
-        if match[:attributes]
-          matched_attributes = match[:attributes].gsub(/\{(immutable|required)\s+(required|immutable)\}/, '{\1_\2}')
-          matched_attributes.split.each do |attribute|
-            attribute.gsub! /\{(immutable|required)_(required|immutable)\}/, '{\1 \2}'
-            property_string = attribute[/#{REGEXP_ATTRIBUTE_DEF}/, -2]
-            properties = Occi::Core::Properties.new
-            if property_string
-              properties.required = true if property_string.include? 'required'
-              properties.mutable = false if property_string.include? 'immutable'
+        def category(string)
+          Occi::Log.debug "[#{self}] Parsing through Occi::Parser::Text.category"
+          # create regular expression from regexp string
+          regexp = Regexp.new( Occi::Settings.compatibility ?  REGEXP_CATEGORY : REGEXP_CATEGORY_STRICT )
+          # match string to regular expression
+          match = regexp.match string
+
+          raise Occi::Errors::ParserInputError, "could not match #{string}" unless match
+
+          term = match[:term].downcase
+          scheme = match[:scheme]
+          title = match[:title]
+          related = match[:rel].to_s.split
+
+          attributes = Occi::Core::Attributes.new
+          if match[:attributes]
+            match[:attributes].split.each do |attribute|
+              property_string = attribute[/#{REGEXP_ATTRIBUTE_DEF}/, -2]
+              properties = Occi::Core::Properties.new
+
+              if property_string
+                properties.required = true if property_string.include? 'required'
+                properties.mutable = false if property_string.include? 'immutable'
+              end
+
+              name = attribute[/#{REGEXP_ATTRIBUTE_DEF}/, 1]
+              attributes.merge! name.split('.').reverse.inject(properties) { |a, n| Occi::Core::Attributes.new(n => a) }
             end
-            name = attribute[/#{REGEXP_ATTRIBUTE_DEF}/, 1]
-            attributes.merge! name.split('.').reverse.inject(properties) { |a, n| Occi::Core::Attributes.new(n => a) }
           end
-        end
-        actions = match[:actions].to_s.split
-        location = match[:location]
-        case match[:class]
+          actions = match[:actions].to_s.split
+          location = match[:location]
+
+          case match[:class]
           when 'kind'
+            Occi::Log.debug "[#{self}] class #{match[:class]} identified as kind"
             Occi::Core::Kind.new scheme, term, title, attributes, related, actions, location
           when 'mixin'
+            Occi::Log.debug "[#{self}] class #{match[:class]} identified as mixin"
             Occi::Core::Mixin.new scheme, term, title, attributes, related, actions, location
           when 'action'
+            Occi::Log.debug "[#{self}] class #{match[:class]} identified as action"
             Occi::Core::Action.new scheme, term, title, attributes
           else
-            raise "Category with class #{match[:class]} not recognized in string: #{string}"
+            raise Occi::Errors::ParserInputError, "Category with class #{match[:class]} not recognized in string: #{string}"
+          end
         end
-      end
 
-      def self.attribute(string)
-        # create regular expression from regexp string
-        regexp = Regexp.new(REGEXP_ATTRIBUTE)
-        # match string to regular expression
-        match = regexp.match string
+        def attribute(string)
+          Occi::Log.debug "[#{self}] Parsing through Occi::Parser::Text.attribute"
+          # create regular expression from regexp string
+          regexp = Regexp.new(REGEXP_ATTRIBUTE)
+          # match string to regular expression
+          match = regexp.match string
+
+          raise Occi::Errors::ParserInputError, "could not match #{string}" unless match
 
-        raise "could not match #{string}" unless match
+          value = match[:string] if match[:string]
 
-        value = match[:string] if match[:string]
+          if match[:number]
+            match[:number].include?('.') ? value = match[:number].to_f : value = match[:number].to_i
+          end
 
-        if match[:number]
-          match[:number].include?('.') ? value = match[:number].to_f : value = match[:number].to_i
+          value = match[:bool] == "true" if match[:bool]
+          Occi::Core::Attributes.split match[:name] => value
         end
 
-        value = match[:bool] == "true" if match[:bool]
-        Occi::Core::Attributes.split match[:name] => value
-      end
+        def link_string(string, source)
+          Occi::Log.debug "[#{self}] Parsing through Occi::Parser::Text.link_string"
+          # create regular expression from regexp string
+          regexp = Regexp.new( Occi::Settings.compatibility ? REGEXP_LINK : REGEXP_LINK_STRICT )
+          # match string to regular expression
+          match = regexp.match string
 
-      def self.link_string(string, source)
-        # create regular expression from regexp string
-        regexp = Regexp.new(REGEXP_LINK)
-        # match string to regular expression
-        match = regexp.match string
-
-        raise "could not match #{string}" unless match
-
-        target = match[:uri]
-        rel = match[:rel]
-        if match[:category].blank?
-          kind = Occi::Core::Link.kind
-        else
-          categories = match[:category].split
-          kind = categories.shift
-          mixins = categories
+          raise Occi::Errors::ParserInputError, "could not match #{string}" unless match
+
+          target = match[:uri]
+          rel = match[:rel]
+          if match[:category].blank?
+            kind = Occi::Core::Link.kind
+          else
+            categories = match[:category].split
+            kind = categories.shift
+            mixins = categories
+          end
+          actions = nil
+          location = match[:self]
+
+          # create an array of the list of attributes
+          attributes = []
+          regexp=Regexp.new '(\\s*'+REGEXP_ATTRIBUTE_REPR.to_s+')'
+          attr_line = match[:attributes].sub(/^\s*;\s*/, ' ')
+          attributes = attr_line.scan(regexp).collect {|matches| matches.first}
+
+          # parse each attribute and create an OCCI Attribute object from it
+          attributes = attributes.inject(Hashie::Mash.new) { |hsh, attribute|
+            hsh.merge!(Occi::Parser::Text.attribute("X-OCCI-Attribute: #{attribute}"))
+          }
+          Occi::Core::Link.new kind, mixins, attributes, actions, rel, target, source, location
         end
-        actions = nil
-        location = match[:self]
-
-        # create an array of the list of attributes
-        attributes = []
-        regexp=Regexp.new '(\\s*'+REGEXP_ATTRIBUTE_REPR.to_s+')'
-        attr_line = match[:attributes].sub(/^\s*;\s*/, ' ')
-        attributes = attr_line.scan(regexp).collect {|matches| matches.first}
-
-        # parse each attribute and create an OCCI Attribute object from it
-        attributes = attributes.inject(Hashie::Mash.new) { |hsh, attribute| hsh.merge!(Occi::Parser::Text.attribute('X-OCCI-Attribute: ' + attribute)) }
-        Occi::Core::Link.new kind, mixins, attributes, actions, rel, target, source, location
-      end
 
-      def self.location(string)
-        # create regular expression from regexp string
-        regexp = Regexp.new(REGEXP_LOCATION)
-        # match string to regular expression
-        match = regexp.match string
+        def location(string)
+          Occi::Log.debug "[#{self}] Parsing through Occi::Parser::Text.location"
+          # create regular expression from regexp string
+          regexp = Regexp.new(REGEXP_LOCATION)
+          # match string to regular expression
+          match = regexp.match string
 
-        raise "could not match #{string}" unless match
+          raise Occi::Errors::ParserInputError, "could not match #{string}" unless match
+
+          match[:location]
+        end
 
-        match[:location]
       end
 
     end

data/lib/occi/parser/xml.rb

@@ -4,14 +4,16 @@ module Occi
       # @param [String] string
       # @return [Occi::Collection]
       def self.collection(string)
-        collection = Occi::Collection.new
-        hash = Hashie::Mash.new(Hash.from_xml(Nokogiri::XML(string)))
-        collection.kinds.merge hash.kinds.collect { |kind| Occi::Core::Kind.new(kind.scheme, kind.term, kind.title, kind.attributes, kind.related, kind.actions) } if hash.kinds
-        collection.mixins.merge hash.mixins.collect { |mixin| Occi::Core::Mixin.new(mixin.scheme, mixin.term, mixin.title, mixin.attributes, mixin.related, mixin.actions) } if hash.mixins
-        collection.actions.merge hash.actions.collect { |action| Occi::Core::Action.new(action.scheme, action.term, action.title, action.attributes) } if hash.actions
-        collection.resources.merge hash.resources.collect { |resource| Occi::Core::Resource.new(resource.kind, resource.mixins, resource.attributes, resource.actions, resource.links) } if hash.resources
-        collection.links.merge hash.links.collect { |link| Occi::Core::Link.new(link.kind, link.mixins, link.attributes) } if hash.links
-        collection
+
+        begin
+          parsed_xml = Nokogiri::XML(string) { |config| config.strict.nonet }
+        rescue Nokogiri::XML::SyntaxError => perr
+          Occi::Log.error "[#{self}] Failed to parse XML input: #{perr.message}"
+          raise Occi::Errors::ParserInputError, perr.message
+        end
+
+        hash = Hashie::Mash.new(Hash.from_xml(parsed_xml))
+        Occi::Collection.new(hash)
       end
     end
   end

data/lib/occi/parser.rb

@@ -1,51 +1,86 @@
-require 'occi/parser/text'
-require 'occi/parser/json'
-require 'occi/parser/xml'
-require 'occi/parser/ova'
-require 'occi/parser/ovf'
+Dir[File.join(File.dirname(__FILE__), 'parser', '*.rb')].each { |file| require file.gsub('.rb', '') }
 
 module Occi
   module Parser
 
-    # Parses an OCCI message and extracts OCCI relevant information
-    # @param [String] media_type the media type of the OCCI message
-    # @param [String] body the body of the OCCI message
-    # @param [true, false] category for text/plain and text/occi media types information e.g. from the HTTP request location is needed to determine if the OCCI message includes a category or an entity
-    # @param [Occi::Core::Resource,Occi::Core::Link] entity_type entity type to use for parsing of text plain entities
-    # @param [Hash] header optional header of the OCCI message
-    # @return [Occi::Collection] list consisting of an array of locations and the OCCI object collection
-    def self.parse(media_type, body, category=false, entity_type=Occi::Core::Resource, header={})
-      Occi::Log.debug '### Parsing request data to OCCI Collection ###'
-      collection = Occi::Collection.new
-
-      # remove trailing HTTP_ prefix if present
-      header = Hash[header.map { |k, v| [k.gsub('HTTP_', '').upcase, v] }]
-
-      if category
-        collection = Occi::Parser::Text.categories(header.map { |k, v| v.to_s.split(',').collect { |w| "#{k}: #{w}" } }.flatten)
-      else
-        if entity_type == Occi::Core::Resource
-          collection = Occi::Parser::Text.resource(header.map { |k, v| v.to_s.split(',').collect { |w| "#{k}: #{w}" } }.flatten)
-        elsif entity_type == Occi::Core::Link
-          collection = Occi::Parser::Text.link(header.map { |k, v| v.to_s.split(',').collect { |w| "#{k}: #{w}" } }.flatten)
-        end
+    class << self
+
+      OCCI_HEADERS = ['Category', 'Link', 'X-OCCI-Location', 'X-OCCI-Attribute', 'Location'].freeze
+
+      # Parses an OCCI message and extracts OCCI relevant information
+      # @param [String] media_type the media type of the OCCI message
+      # @param [String] body the body of the OCCI message
+      # @param [true, false] category for text/plain and text/occi media types information e.g. from the HTTP request location is needed to determine if the OCCI message includes a category or an entity
+      # @param [Occi::Core::Resource,Occi::Core::Link] entity_type entity type to use for parsing of text plain entities
+      # @param [Hash] header optional header of the OCCI message
+      # @return [Occi::Collection] list consisting of an array of locations and the OCCI object collection
+      def parse(media_type, body, category=false, entity_type=Occi::Core::Resource, header={})
+        Occi::Log.debug "[#{self}] Parsing request data to OCCI Collection"
+        header = headers_to_arys(header)
+
+        Occi::Log.debug "[#{self}] Parsing headers: #{header.inspect}"
+        collection = parse_headers(header, category, entity_type)
+
+        Occi::Log.debug "[#{self}] Parsing #{media_type} from body"
+        coll_body = parse_body(media_type, body, category, entity_type)
+        collection.merge! coll_body if coll_body && !coll_body.empty?
+
+        collection
       end
 
-      case media_type
+      def locations(media_type, body, header)
+        locations = []
+        locations << header['Location'] if header['Location'] && !header['Location'].blank?
+        header = headers_to_arys(header)
+
+        Occi::Log.debug "[#{self}] Parsing locations from request headers: #{header.inspect}"
+        locations << Occi::Parser::Text.locations(header)
+
+        Occi::Log.debug "[#{self}] Parsing #{media_type} locations from body"
+        case media_type
         when 'text/uri-list'
+          locations << body.split("\n")
+        when 'text/plain', nil
+          locations << Occi::Parser::Text.locations(body.split "\n")
+        else
           nil
+        end
+
+        locations.flatten
+      end
+
+      private
+
+      def parse_headers(header, category, entity_type)
+        if category
+          Occi::Log.debug "[#{self}] Parsing categories from headers"
+          collection = Occi::Parser::Text.categories(header)
+        else
+          if entity_type == Occi::Core::Resource
+            Occi::Log.debug "[#{self}] Parsing a resource from headers"
+            collection = Occi::Parser::Text.resource(header)
+          elsif entity_type == Occi::Core::Link
+            Occi::Log.debug "[#{self}] Parsing a link from headers"
+            collection = Occi::Parser::Text.link(header)
+          else
+            raise Occi::Errors::ParserTypeError, "Entity type '#{entity_type}' not supported"
+          end
+        end
+
+        collection
+      end
+
+      def parse_body(media_type, body, category, entity_type)
+        collection = Occi::Collection.new
+
+        case media_type
+        when 'text/uri-list'
+          raise Occi::Errors::ParserTypeError, "Type 'text/uri-list' not supported by parse(). Call method #{self}.locations() to parse URI lists"
         when 'text/occi'
+          Occi::Log.warn "Input type text/occi was passed to the parser in request body. All text/occi content MUST be passed in headers. Request body was not processed. The unprocessed content follows\n#{body}" unless body.blank?
           nil
         when 'text/plain', nil
-          if category
-            collection = Occi::Parser::Text.categories body.split "\n"
-          else
-            if entity_type == Occi::Core::Resource
-              collection = Occi::Parser::Text.resource body.split "\n"
-            elsif entity_type == Occi::Core::Link
-              collection = Occi::Parser::Text.link body.split "\n"
-            end
-          end
+          collection = parse_body_plain(body, category, entity_type)
         when 'application/occi+json', 'application/json'
           collection = Occi::Parser::Json.collection body
         when 'application/occi+xml', 'application/xml'
@@ -55,24 +90,39 @@ module Occi
         when 'application/ova'
           collection = Occi::Parser::Ova.collection body
         else
-          raise "Content Type not supported"
+          raise Occi::Errors::ParserTypeError, "Content type #{media_type} not supported"
+        end
+
+        collection
       end
-      collection
-    end
 
-    def self.locations(media_type, body, header)
-      locations = Occi::Parser::Text.locations header.map { |k, v| v.to_s.split(',').collect { |w| "#{k}: #{w}" } }.flatten
-      locations << header['Location'] if !header['Location'].nil? && header['Location'].any?
-      case media_type
-        when 'text/uri-list'
-          locations << body.split("\n")
-        when 'text/plain', nil
-          locations << Occi::Parser::Text.locations(body.split "\n")
+      def parse_body_plain(body, category, entity_type)
+        if category
+          collection = Occi::Parser::Text.categories body.split "\n"
         else
-          nil
+          if entity_type == Occi::Core::Resource
+            collection = Occi::Parser::Text.resource body.split "\n"
+          elsif entity_type == Occi::Core::Link
+            collection = Occi::Parser::Text.link body.split "\n"
+          else
+            raise Occi::Errors::ParserTypeError, "Entity type #{entity_type} not supported"
+          end
+        end
+
+        collection
+      end
+
+      def headers_to_arys(header)
+        # remove the HTTP_ prefix if present and capitalize keys
+        header = Hash[header.map { |k, v| [k.gsub('HTTP_', '').capitalize, v] }]
+        header['X-OCCI-Location'] = header['X-occi-location'] if header['X-occi-location']
+        header['X-OCCI-Attribute'] = header['X-occi-attribute'] if header['X-occi-attribute']
+
+        header.delete_if { |k, v| v.blank? || !OCCI_HEADERS.include?(k) }
+
+        header.map { |k, v| v.to_s.split(',').collect { |w| "#{k}: #{w}" } }.flatten
       end
 
-      locations.flatten
     end
 
   end

data/lib/occi/settings.rb

@@ -2,8 +2,9 @@ module Occi
   class Settings < Settingslogic
     gem_root = File.expand_path '../../..', __FILE__
 
+    source "#{ENV['HOME']}/.occi" if File.readable?("#{ENV['HOME']}/.occi")
     source "#{gem_root}/config/occi.yml"
-    source open(ENV['HOME']+'/.occi') if File.file?(ENV['HOME']+'/.occi')
+
     namespace 'core'
   end
 end

data/lib/occi/version.rb

@@ -1,3 +1,3 @@
 module Occi
-  VERSION = "4.1.3" unless defined?(::Occi::VERSION)
+  VERSION = "4.2.0" unless defined?(::Occi::VERSION)
 end