eeml 0.0.1

data/lib/eeml/feed_retriever.rb

@@ -0,0 +1,103 @@
+require 'uri'
+require 'net/http'
+module Eeml
+
+  class FeedRetriever
+
+    DEFAULT_TIMEOUT = 5
+    PREMIUM_ENVIRONMENT_AGE = raise 3
+
+    attr_accessor :retrieval_errors #will hold an array of string error messages populated during feed retrieval.  currently populated only in fetch_remote_data
+    attr_accessor :logger
+    attr_accessor :feed_url, :retrieved_at
+    attr_accessor :feed_changed, :feed_retrieved
+    attr_accessor :feed_content, :mime_type
+
+    def initialize
+    end
+    
+    # only attempt to retrieve data if request is after our minimum time delta
+    #currently makes use of get_response() and fetch() to do actual retrieval.
+    def fetch_remote_data
+      @retrieval_errors = []
+      logger.debug("*** Attempting to fetch remote data")
+
+      # only attempt to retrieve data if this environment has a feed_url
+      if !self.feed_url.blank? && (self.retrieved_at.nil? || (Time.now.utc - self.retrieved_at.utc) > PREMIUM_ENVIRONMENT_AGE)
+        logger.debug("*** Our refresh delta has passed so retrieve remote data")
+        
+        self.feed_changed = false
+        self.feed_retrieved = false
+
+        response = get_response
+        
+        case response
+        when Net::HTTPSuccess
+          logger.debug("*** 200 ok... checking mime type #{response.content_type}.")
+          if MIME_TYPES.include?(response.content_type)
+            logger.debug("*** We have a valid mime type")
+
+            self.feed_content = response.body.to_s.strip
+            self.mime_type = response.content_type
+
+            self.retrieved_at = Time.now.utc.to_s(:db)
+          else
+            logger.debug("*** wrong mime-type.")
+            white_list = ['text/html', 'text/javascript', 'application/javascript'] # acceptably WRONG header values.
+            filtered_advice = ( white_list.member?(response.content_type) ? "  Got '#{response.content_type}'." : "" ) 
+            @retrieval_errors << "Wrong mime-type.  Need application/xml, text/csv, or variants." + filtered_advice
+          end
+        else
+          self.feed_retrieved = false
+          self.feed_changed = false
+          logger.debug("*** Unable to fetch remote data")
+        end
+      else
+        logger.debug("*** No feed url present or refresh delta not yet expired - don't do nothin")
+        # TODO remove after development
+      end
+    rescue URI::InvalidURIError, Timeout::Error, SystemCallError => e
+      self.feed_retrieved = false
+      self.feed_changed = false
+      @retrieval_errors << "Url bad or unavailable."
+      logger.error("*** Error retrieving feed from remote source: #{e}")
+    end
+
+    # private
+
+    # separating this method out makes mocking our response fairly simple
+    # basically we just create a dummy response object, and override this
+    # method with a stubbed version that returns our dummy response
+    def get_response
+      return fetch(feed_url)
+    end
+
+    # TODO: update test specs so this passes properly
+    # this fetch method recursively follows redirections up to a maximum depth of 10 redirections
+    def fetch(uri_str, limit = 10)
+      uri = create_uri(uri_str)
+
+      logger.debug("*** Fetching content from :#{uri}")
+      http_client = Net::HTTP.new(uri.host, uri.port)
+      
+      # the default timeout appears to be 60 seconds. this is very long
+      # override it to be 5 seconds
+      http_client.open_timeout = DEFAULT_TIMEOUT
+      http_client.read_timeout = DEFAULT_TIMEOUT
+      response = http_client.request_get(uri.request_uri)
+      logger.debug("*** Got response: #{response}")
+      case response
+      when Net::HTTPSuccess then response
+      when Net::HTTPRedirection then fetch(response['location'], limit - 1)
+      else response
+      end
+    end
+
+    def create_uri(uri_str)
+      logger.debug("*** Creating uri from: #{uri_str}")
+      uri = URI.parse(uri_str)
+      raise URI::InvalidURIError unless uri.is_a?(URI::HTTP) or uri.is_a?(URI::HTTPS)
+      return uri
+    end
+  end
+end

data/lib/eeml/json_environment_parser.rb

@@ -0,0 +1,11 @@
+module Eeml
+  #a parser for json environments
+  class JsonEnvironmentParser
+    def make_environment_from_json(json_str)
+      env = Environment.new
+      return env
+    end
+  end
+end
+
+

data/lib/eeml/libxml_eeml_output_v005.rb

@@ -0,0 +1,120 @@
+module Eeml
+  class LibXMLEemlOutputV005 # :nodoc:
+    include LibXML
+    include Constants
+    
+    # main method. creates an EEML 5 document for the given environment.
+    def to_eeml(environment)
+      doc = XML::Document.new
+      eeml = doc.root = XML::Node.new('eeml')
+      XML::Namespace.new(eeml, nil, EEML_HREF)
+      XML::Namespace.new(eeml, 'xsi', XSI_NAMESPACE)
+      eeml['version'] = EEML_VERSION
+      eeml['xsi:schemaLocation'] = EEML_SCHEMA_LOCATION
+      eeml << xml_node_for_environment(environment)
+
+      return doc.to_s(:encoding => XML::Encoding::UTF_8)
+    end
+
+    def xml_node_for_environment(environment)
+      environment_node = XML::Node.new('environment')
+
+      #TODO: write all these strings out safely for xml
+      
+      environment_node['updated'] = environment.updated.strftime(XML_TIME_FORMAT_STRING) unless environment.updated.nil?      
+      environment_node['id'] = environment.identifier.to_s unless environment.identifier.blank?
+      environment_node['creator'] = environment.creator.to_s unless environment.creator.blank?
+      
+      unless environment.title.blank?
+        environment_node << title_node = XML::Node.new('title')
+        title_node << environment.title
+      end
+
+      unless environment.feed_url.blank?
+        environment_node << feed_node = XML::Node.new('feed')
+        feed_node << environment.feed_url
+      end
+      
+      unless environment.status.blank?
+        environment_node << status_node = XML::Node.new('status')
+        status_node << environment.status
+      end
+
+      unless environment.description.blank?
+        environment_node << description_node = XML::Node.new('description')
+        description_node << environment.description
+      end
+
+      unless environment.icon.blank?
+        environment_node << icon_node = XML::Node.new('icon')
+        icon_node << environment.icon
+      end
+
+      unless environment.website.blank?
+        environment_node << website_node = XML::Node.new('website')
+        website_node << environment.website
+      end
+
+      unless environment.email.blank?
+        environment_node << email_node = XML::Node.new('email')
+        email_node << environment.email
+      end
+
+      unless environment.location.nil?
+        environment_node << location_node = XML::Node.new('location')
+        location_node['domain'] = environment.location.domain
+        location_node['exposure'] = environment.location.exposure unless environment.location.exposure.blank?
+        location_node['disposition'] = environment.location.disposition unless environment.location.disposition.blank?
+        
+        unless environment.location.name.blank?
+          location_node << location_name_node = XML::Node.new('name')
+          location_name_node << environment.location.name
+        end
+
+        location_node << lat_node = XML::Node.new('lat')
+        lat_node << environment.location.latitude
+
+        location_node << lng_node = XML::Node.new('lon')
+        lng_node << environment.location.longitude
+
+        unless environment.location.elevation.blank?
+          location_node << elevation_node = XML::Node.new('ele')
+          elevation_node << environment.location.elevation
+        end
+      end
+
+      environment.datastreams.each do |datastream|
+        environment_node << datastream_to_xml_node(datastream)
+      end
+
+      return environment_node
+    end
+
+    def datastream_to_xml_node(datastream)
+      datastream_node = XML::Node.new('data')
+      datastream_node['id'] = datastream.identifier.to_s
+
+      datastream.tags.each do |tag|
+        tag_node = XML::Node.new('tag')
+        tag_node << tag
+        datastream_node << tag_node
+      end    
+
+      datastream_node << value_node = XML::Node.new('value')
+
+      value_node['minValue'] = datastream.min_value.to_s unless datastream.min_value.to_s.empty?
+      value_node['maxValue'] = datastream.max_value.to_s unless datastream.max_value.to_s.empty?
+
+      value_node << datastream.value.to_s
+      
+      unless datastream.unit_value.to_s.empty? && datastream.unit_type.to_s.empty? && datastream.unit_symbol.to_s.empty?
+        datastream_node << unit_node = XML::Node.new('unit')
+        unit_node['type'] = datastream.unit_type.to_s unless datastream.unit_type.to_s.empty?
+        unit_node['symbol'] = datastream.unit_symbol.to_s unless datastream.unit_symbol.to_s.empty?
+        unit_node << datastream.unit_value.to_s unless datastream.unit_value.to_s.empty?
+      end
+
+      return datastream_node
+    end
+  end
+end

data/lib/eeml/libxml_eeml_parser_v005.rb

@@ -0,0 +1,179 @@
+require "parsedate.rb"
+module Eeml
+  #a parser for xml eeml v005, implemented with LibXML
+  class LibXMLEemlParserV005 # :nodoc:
+    include LibXML
+
+    #main method
+    
+    #take an xml string, and create an Environment from it
+    def make_environment_from_xml(xml_str)
+      doc = parse_xml(xml_str)
+      return extract_environment(doc)
+    end
+
+    protected
+
+    def parse_xml(xml_str)
+      errors = []
+      #http://libxml.rubyforge.org/rdoc/classes/LibXML/XML/Error.html
+      #TODO: is the error handler set up per thread? (XML::Error.set_handler)
+      XML::Error.set_handler { |error| errors << error } 
+  
+      #TODO: performance - is this expensive?
+      #TODO: are these configurations per-thread?  If they're global (e.g. class variables) then we shouldn't be setting them here.
+      XML.default_line_numbers=true
+      
+      parser = XML::Parser.string(xml_str)
+      begin
+        doc = parser.parse
+      rescue XML::Error => e
+        #note: errors var available here, too.        
+        raise BadXML, "Malformed xml: #{e.class}: #{e}", e.backtrace
+      end
+      #validation?
+      # seems we have to recreate our XML::Schema object on each invocation
+      # else libxml segfaults very quickly
+      #doc.validate_schema(XML::Schema.from_string(IO.read(LOCAL_EEML_SCHEMA_LOCATION)))
+      return doc
+    end
+
+
+    def extract_environment(doc)
+      env = Environment.new
+      doc.root.namespaces.default_prefix = 'x'
+
+      env_node = find_first_node_or_fail(doc, 'x:environment', 'environment')
+      env.identifier = env_node['id']
+      env.updated = Time.mktime(*ParseDate.parsedate(env_node['updated'])) if !env_node['updated'].nil?
+
+      
+      env.creator = env_node['creator']
+
+      env.title       = optional_content(env_node, 'x:title', 'title')
+      env.feed_url    = optional_content(env_node, 'x:feed', 'feed')
+      env.description = optional_content(env_node, 'x:description', 'description')
+      env.website     = optional_content(env_node, 'x:website', 'website')
+      env.status      = optional_content(env_node, 'x:status', 'status')
+      env.email       = optional_content(env_node, 'x:email', 'email')
+      env.icon        = optional_content(env_node, 'x:icon', 'icon')
+
+      #find_first_node_or_fail(env_node, 'x:location', 'location')
+      loc_node = env_node.find_first('x:location')
+      env.location    = extractLocation(loc_node) if loc_node
+
+      datastream_nodes = env_node.find('x:data')
+      # raise NoDataStreams.new, "no datastreams found"  if datastream_nodes.empty?
+      env.datastreams = extractDataStreams(datastream_nodes) unless datastream_nodes.empty?
+
+      return env
+    end
+
+    def extractLocation(node)
+      #<location domain="physical" exposure="outdoor" disposition="mobile">
+      #  <lat>50.1</lat>
+      #  <lon>48.7</lon>
+      #  <ele>1.34</ele>
+      #</location>
+      raise "given nil node" if node.nil?
+      loc = Location.new
+      loc.domain = node['domain']
+      loc.disposition = node['disposition']
+      loc.exposure = node['exposure']
+      loc.name = optional_content(node, 'x:name', 'name')
+      loc.latitude = optional_content(node, 'x:lat', 'lat')
+      loc.longitude = optional_content(node, 'x:lon', 'lon')
+      loc.elevation = optional_content(node, 'x:ele', 'ele')
+      return loc
+    end
+
+    #return an array (TODO: or a hash?) of DataStream objects from the given list of data nodes
+    def extractDataStreams(nodes)
+      #<data id="blah1">...</data><data id="blah2">...</data>
+      dataStreams = []
+      nodes.each do |node|        
+        dataStreams << extractDataStream(node)
+      end
+      return dataStreams
+    end
+
+    #builds and returns a detailed exception of the given class, for problems concerning the given node (or its missing children)
+    #details include node's name and line number (zero if not available)
+    def exception_for_node(node, exception_class, message)
+      ex = exception_class.new(message)
+      ex.line_num = node.line_num
+      ex.node_name = node_name_or_root(node)
+      return ex
+    end
+
+
+    def extractDataStream(node)
+      #<data id="0">
+      #<tag>some_tag</tag>
+      #<tag>another_tag</tag>
+      #<value minValue="0.0" maxValue="1022.0">0</value>
+      #<unit symbol="C" type="basicSI">Celsius</unit>
+      #</data>
+      data = DataStream.new
+      raise MissingAttribute.new('id', node.name) if node['id'].nil?
+      data.identifier = node['id']
+      node.find('x:tag').each do |tag_node|
+        data.tags << tag_node.content
+      end
+
+      value_nodes = node.find('x:value')
+      raise exception_for_node(node, DataMissingValue, "Data node is missing value node.") if value_nodes.empty?
+      raise exception_for_node(node, DataHasMultipleValues, "Data node has multiple 'value' nodes.") if value_nodes.size > 1
+
+      value_node = value_nodes.first
+      data.min_value = value_node['minValue']
+      data.max_value = value_node['maxValue']
+      data.value = value_node.content
+
+      unit_nodes = node.find('x:unit')
+      raise exception_for_node(node, DataHasMultipleUnits, "Data node has multiple 'unit' nodes.") if unit_nodes.size > 1
+
+      unit_node = unit_nodes.first
+      unless unit_node.nil?
+        data.unit_symbol = unit_node['symbol']
+        data.unit_type = unit_node['type']
+        data.unit_value = unit_node.content
+      end
+
+      return data
+    end
+
+    #Helpers ------------------------------------------------------------------
+    #Consider mixing these in to the libxml parser for more readable code
+    
+    #raises MissingNode if the node isn't there
+    def mandatory_content(base_node, xpath, description)
+      node = base_node.find_first(xpath)
+      raise(MissingNode.new(node_name_or_root(base_node), description, xpath)) if node.nil?
+      return node.content
+    end
+
+    #returns the node's content, or the given default if the node isn't there (default itself defaults to nil)
+    #description isn't used, but keeps our signature same as mandatory_content(), up to that point.
+    def optional_content(base_node, xpath, description, default = nil)
+      node = base_node.find_first(xpath)
+      return node.nil? ? default : node.content
+    end
+
+
+    #get the name of the given node if it is a node, or 'root' if it is a doc.
+    #for use only for error messages
+    def node_name_or_root(node)
+      node.respond_to?(:name) ? node.name : 'root'
+    end
+
+    def find_first_node_or_fail(base_node, xpath, description)
+      node = base_node.find_first(xpath)
+      raise(MissingNode.new(node_name_or_root(base_node), description, xpath)) if node.nil?
+      return node
+    end
+
+  end
+
+end
+

data/lib/eeml/output_registry.rb

@@ -0,0 +1,13 @@
+module Eeml
+  class OutputRegistry
+    #look at the given xml, build and return a new v005 or 006 parser, accordingly
+    def self.get_xml_output_for(version = EEML_VERSION)
+      LibXMLEemlOutputV005.new
+    end
+
+    def self.get_json_output_for(version = EEML_VERSION)
+      JsonEnvironmentParser.new
+    end
+
+  end
+end

data/lib/eeml/parser_registry.rb

@@ -0,0 +1,14 @@
+module Eeml
+  class ParserRegistry
+    #look at the given xml, build and return a new v005 or 006 parser, accordingly
+    def self.get_xml_parser_for(xml_str)
+      LibXMLEemlParserV005.new
+    end
+
+    def self.get_json_parser_for(json_str)
+      JsonEnvironmentParser.new
+    end
+
+  end
+end
+

data/lib/eeml.rb

@@ -0,0 +1,35 @@
+#TODO: what's going on here and why? 
+#add this dir to the search path (?)
+$:.unshift(File.dirname(__FILE__))
+
+require 'logger' #std lib
+require 'blank'
+require 'libxml'
+require 'json'
+require 'eeml/constants'
+require 'eeml/exceptions'
+require 'eeml/feed_output'
+require 'eeml/environment'
+require 'eeml/libxml_eeml_parser_v005'
+require 'eeml/json_environment_parser'
+require 'eeml/parser_registry'
+require 'eeml/output_registry'
+require 'eeml/libxml_eeml_output_v005'
+
+
+module Eeml
+
+  # enable logger before including everything else, in case we ever want to log initialization 
+  ##TODO: this config should be environment-specific (e.g. test/production).  Tests can stub.
+  Environment.logger = Logger.new(STDERR)
+
+  # library version number
+  VERSION = '0.0.1'
+  #TODO: put in some configuration file, not here
+  LOCAL_EEML_SCHEMA_LOCATION = 'schemas/eeml/005.xsd'
+
+
+
+end #module
+
+

data/schemas/eeml/005.xsd

@@ -0,0 +1,134 @@
+<?xml version="1.0" encoding="iso-8859-1"?>
+<xsd:schema xmlns="http://www.eeml.org/xsd/005" elementFormDefault="qualified" targetNamespace="http://www.eeml.org/xsd/005" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
+  <xsd:element name="eeml">
+    <xsd:complexType>
+      <xsd:choice>
+        <xsd:element maxOccurs="unbounded" name="environment">
+          <xsd:complexType>         
+            <xsd:sequence>
+              <xsd:element minOccurs="0" name="title" type="xsd:string" />
+              <xsd:element minOccurs="0" name="feed" type="xsd:anyURI" />
+              <xsd:element minOccurs="0" name="status">
+                <xsd:simpleType>
+                  <xsd:restriction base="xsd:string">
+                    <xsd:enumeration value="frozen" />
+                    <xsd:enumeration value="live" />
+                  </xsd:restriction>
+                </xsd:simpleType>
+              </xsd:element>
+              <xsd:element minOccurs="0" name="description" type="xsd:string" />
+              <xsd:element minOccurs="0" name="icon" type="xsd:anyURI" />
+              <xsd:element minOccurs="0" name="website" type="xsd:anyURI" />
+              <xsd:element minOccurs="0" name="email" type="xsd:string" />
+              <xsd:element minOccurs="0" name="location">
+                <xsd:complexType>
+                  <xsd:sequence>
+                    <xsd:element minOccurs="0" name="name" type="xsd:string" />
+                    <xsd:element name="lat">
+                      <xsd:simpleType>
+                        <xsd:restriction base="xsd:double">
+                          <xsd:minInclusive value="-90" />
+                          <xsd:maxInclusive value="90" />
+                        </xsd:restriction>
+                      </xsd:simpleType>
+                    </xsd:element>
+                    <xsd:element name="lon">
+                      <xsd:simpleType>
+                        <xsd:restriction base="xsd:double">
+                          <xsd:minInclusive value="-180" />
+                          <xsd:maxInclusive value="180" />
+                        </xsd:restriction>
+                      </xsd:simpleType>
+                    </xsd:element>
+                    <xsd:element minOccurs="0" maxOccurs="1" name="ele" type="xsd:double" />
+                  </xsd:sequence>
+                  <xsd:attribute name="exposure" use="optional">
+                    <xsd:simpleType>
+                      <xsd:restriction base="xsd:string">
+                        <xsd:enumeration value="indoor" />
+                        <xsd:enumeration value="outdoor" />
+                      </xsd:restriction>
+                    </xsd:simpleType>
+                  </xsd:attribute>
+                  <xsd:attribute name="domain" use="required">
+                    <xsd:simpleType>
+                      <xsd:restriction base="xsd:string">
+                        <xsd:enumeration value="physical" />
+                        <xsd:enumeration value="virtual" />
+                      </xsd:restriction>
+                    </xsd:simpleType>
+                  </xsd:attribute>
+                  <xsd:attribute name="disposition" use="optional">
+                    <xsd:simpleType>
+                      <xsd:restriction base="xsd:string">
+                        <xsd:enumeration value="fixed" />
+                        <xsd:enumeration value="mobile" />
+                      </xsd:restriction>
+                    </xsd:simpleType>
+                  </xsd:attribute>
+                </xsd:complexType>
+              </xsd:element>            
+              <xsd:element minOccurs="1" maxOccurs="unbounded" name="data">
+                <xsd:complexType>
+                  <xsd:sequence>
+                    <xsd:element minOccurs="0" maxOccurs="unbounded" name="tag" type="xsd:string" />
+                    <xsd:element name="value">
+                      <xsd:complexType>
+                        <xsd:simpleContent>
+                          <xsd:extension base="xsd:string">
+                            <xsd:attribute name="minValue" type="xsd:string" use="optional" />
+                            <xsd:attribute name="maxValue" type="xsd:string" use="optional" />
+                          </xsd:extension>
+                        </xsd:simpleContent>
+                      </xsd:complexType>
+                    </xsd:element>
+                    <xsd:element minOccurs="0" maxOccurs="1" name="unit">
+                      <xsd:complexType>
+                        <xsd:simpleContent>
+                          <xsd:extension base="xsd:string">
+                            <xsd:attribute name="symbol" type="xsd:string" use="optional">
+                            </xsd:attribute>
+                            <xsd:attribute name="type" use="optional">
+                              <xsd:simpleType>
+                                <xsd:restriction base="xsd:string">
+                                  <xsd:enumeration value="basicSI" />
+                                  <xsd:enumeration value="derivedSI" />
+                                  <xsd:enumeration value="conversionBasedUnits" />
+                                  <xsd:enumeration value="derivedUnits" />
+                                  <xsd:enumeration value="contextDependentUnits" />
+                                </xsd:restriction>
+                              </xsd:simpleType>
+                            </xsd:attribute>
+                          </xsd:extension>
+                        </xsd:simpleContent>
+                      </xsd:complexType>
+                    </xsd:element>
+                  </xsd:sequence>
+                  <xsd:attribute name="id" type="xsd:nonNegativeInteger" use="required" />
+                </xsd:complexType>
+              </xsd:element>
+             </xsd:sequence>            
+            <xsd:attribute name="updated" use="optional">
+              <xsd:simpleType>
+                <xsd:restriction base="xsd:dateTime" />
+              </xsd:simpleType>
+            </xsd:attribute>
+            <xsd:attribute fixed="http://www.haque.co.uk" name="creator" use="optional">
+              <xsd:simpleType>
+                <xsd:restriction base="xsd:string" />
+              </xsd:simpleType>
+            </xsd:attribute>
+            <xsd:attribute name="id" type="xsd:nonNegativeInteger" use="optional" />
+          </xsd:complexType>
+        </xsd:element>
+      </xsd:choice>
+      <xsd:attribute name="version" use="optional">
+        <xsd:simpleType>
+          <xsd:restriction base="xsd:positiveInteger">            
+            <xsd:enumeration value="5" />
+          </xsd:restriction>
+        </xsd:simpleType>
+      </xsd:attribute>
+    </xsd:complexType>
+  </xsd:element>
+</xsd:schema>

data/test/data/doc_1.json

@@ -0,0 +1,2 @@
+foo
+

data/test/data/doc_1.xml

@@ -0,0 +1,32 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<eeml xmlns="http://www.eeml.org/xsd/005" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="5" xsi:schemaLocation="http://www.eeml.org/xsd/005 http://www.eeml.org/xsd/005/005.xsd">
+  <environment updated="2009-02-11T10:56:56Z" id="1247" creator="http://example.com/creator/">
+    <title>title here</title>
+    <feed>http://example.com/api/1247.xml</feed>
+    <status>frozen</status>
+    <description>description here</description>
+    <icon>http://example.com/some/icon.gif</icon>
+    <website>http://example.com/studio/</website>
+    <email>someone@example.com</email>
+    <location domain="physical" exposure="outdoor" disposition="mobile">
+      <name>Up on the roof (somewhere)</name>
+      <lat>50.1</lat>
+      <lon>48.7</lon>
+      <ele>1.34</ele>
+    </location>
+    <data id="0">
+      <tag>tagD0</tag>
+      <value minValue="-9999.0" maxValue="1022.0">0</value>
+      <unit type="basicSI" symbol="C">Celsius</unit>
+    </data>
+    <data id="1">
+      <value minValue="0.0" maxValue="1023.0">33</value>
+    </data>
+    <data id="2">
+      <tag>tagD2a</tag>
+      <tag>tagD2b</tag>
+      <tag>tagD2c</tag>
+      <value minValue="23.4" maxValue="1021.0">42.1</value>
+    </data>
+  </environment>
+</eeml>

data/test/data/minimal.xml

@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<eeml xmlns="http://www.eeml.org/xsd/005">
+  <environment>
+    <title>Minimal</title>
+    <data id="0">
+      <value>36.2</value>
+    </data>
+  </environment>
+</eeml>

data/test/data/out_empty.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<eeml xmlns="http://www.eeml.org/xsd/005" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="5" xsi:schemaLocation="http://www.eeml.org/xsd/005 http://www.eeml.org/xsd/005/005.xsd">
+  <environment/>
+</eeml>