acceptable 0.2.1

data/README.rdoc

@@ -0,0 +1,28 @@
+== REQUIREMENTS:
+
+rack (>=1.0.0)
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2009
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/lib/rack/acceptable/const.rb

@@ -0,0 +1,37 @@
+module Rack #:nodoc:
+  module Acceptable #:nodoc:
+    module Const
+
+      WILDCARD                  = '*'.freeze
+      MEDIA_RANGE_WILDCARD      = '*/*'.freeze
+      IDENTITY                  = 'identity'.freeze
+      ISO_8859_1                = 'iso-8859-1'.freeze
+      TEXT                      = 'text'.freeze
+
+      COMMA                     = ','.freeze
+      EMPTY_STRING              = ''.freeze
+      HYPHEN                    = '-'.freeze
+      SEMICOLON                 = ';'.freeze
+      SLASH                     = '/'.freeze
+
+      ENV_HTTP_ACCEPT           = 'HTTP_ACCEPT'.freeze
+      ENV_HTTP_ACCEPT_ENCODING  = 'HTTP_ACCEPT_ENCODING'.freeze
+      ENV_HTTP_ACCEPT_CHARSET   = 'HTTP_ACCEPT_CHARSET'.freeze
+      ENV_HTTP_ACCEPT_LANGUAGE  = 'HTTP_ACCEPT_LANGUAGE'.freeze
+
+      CHARSET                   = 'charset'.freeze
+      CONTENT_TYPE              = 'Content-Type'.freeze
+      CONTENT_LENGTH            = 'Content-Length'.freeze
+
+      TEXT_SLASH_PLAIN          = 'text/plain'.freeze
+
+      NOT_ACCEPTABLE            = "An appropriate representation of the requested resource could not be found.\n".freeze
+      NOT_ACCEPTABLE_RESPONSE   = [406, {
+        CONTENT_TYPE => TEXT_SLASH_PLAIN, CONTENT_LENGTH => '76' },
+        [NOT_ACCEPTABLE]].freeze
+
+    end
+  end
+end
+
+# EOF

data/lib/rack/acceptable/data/mime.types

@@ -0,0 +1,20 @@
+application/atom+xml          atom
+application/javascript        js
+application/json              json
+application/octet-stream      bin class iso dmg dist pkg dump
+application/xhtml+xml         xhtml
+application/xml               xml
+application/xml-dtd           dtd
+application/xslt+xml          xslt
+application/zip               zip
+image/bmp                     bmp
+image/gif                     gif
+image/jpeg                    jpeg jpg jpe
+image/png                     png
+image/tiff                    tiff tif
+image/vnd.djvu                djvu djv
+image/x-icon                  ico
+text/css                      css
+text/csv                      csv
+text/html                     html htm
+text/plain                    txt text conf log

data/lib/rack/acceptable/language_tag.rb

@@ -0,0 +1,405 @@
+require 'rack/acceptable/utils'
+
+module Rack #:nodoc:
+  module Acceptable #:nodoc:
+
+    # inspired by the 'langtag' gem (author: Martin Dürst)
+    # http://rubyforge.org/projects/langtag/
+    # http://www.langtag.net/
+    #
+    class LanguageTag
+
+      GRANDFATHERED_TAGS = {
+        'art-lojban'  => 'jbo' ,
+        'cel-gaulish' => nil   ,
+        'en-gb-oed'   => nil   ,
+        'i-ami'       => 'ami' ,
+        'i-bnn'       => 'bnn' ,
+        'i-default'   => nil   ,
+        'i-enochian'  => nil   ,
+        'i-hak'       => 'hak' ,
+        'i-klingon'   => 'tlh' ,
+        'i-lux'       => 'lb'  ,
+        'i-mingo'     => nil   ,
+        'i-navajo'    => 'nv'  ,
+        'i-pwn'       => 'pwn' ,
+        'i-tao'       => 'tao' ,
+        'i-tay'       => 'tay' ,
+        'i-tsu'       => 'tsu' ,
+        'no-bok'      => 'nb'  ,
+        'no-nyn'      => 'nn'  ,
+        'sgn-be-fr'   => 'sfb' ,
+        'sgn-be-nl'   => 'vgt' ,
+        'sgn-ch-de'   => 'sgg' ,
+        'zh-guoyu'    => 'cmn' ,
+        'zh-hakka'    => 'hak' ,
+        'zh-min'      => nil   ,
+        'zh-min-nan'  => 'nan' ,
+        'zh-xiang'    => 'hsn' 
+      }.freeze
+
+      attr_accessor :primary, :extlang, :script, :region, :variants, :extensions, :privateuse
+
+      #--
+      # RFC 5646, sec. 2.2.2:
+      # Although the ABNF production 'extlang' permits up to three
+      # extended language tags in the language tag, extended language
+      # subtags MUST NOT include another extended language subtag in
+      # their 'Prefix'.  That is, the second and third extended language
+      # subtag positions in a language tag are permanently reserved and
+      # tags that include those subtags in that position are, and will
+      # always remain, invalid.
+      #++
+
+      language    = '([a-z]{2,8}|[a-z]{2,3}(?:-[a-z]{3})?)'
+      script      = '(?:-([a-z]{4}))?'
+      region      = '(?:-([a-z]{2}|\d{3}))?'
+      variants    = '(?:-[a-z\d]{5,8}|-\d[a-z\d]{3})*'
+      extensions  = '(?:-[a-wy-z\d]{1}(?:-[a-z\d]{2,8})+)*'
+      privateuse  = '(?:-x(?:-[a-z\d]{1,8})+)?'
+
+      LANGTAG_COMPOSITION_REGEX   = /^#{language}#{script}#{region}(?=#{variants}#{extensions}#{privateuse}$)/o.freeze
+      LANGTAG_INFO_REGEX          = /^#{language}#{script}#{region}(#{variants})#{extensions}#{privateuse}$/o.freeze
+      PRIVATEUSE_REGEX            = /^x(?:-[a-z\d]{1,8})+$/i.freeze
+
+      PRIVATEUSE = 'x'.freeze
+
+      class << self
+
+        # Checks if the +String+ passed could be treated as 'privateuse' Language-Tag.
+        # Works case-insensitively.
+        #
+        def privateuse?(tag)
+          PRIVATEUSE_REGEX === tag
+        end
+
+        # Checks if the +String+ passed represents a 'grandgathered' Language-Tag.
+        # Works case-insensitively.
+        #
+        def grandfathered?(tag)
+          GRANDFATHERED_TAGS.key?(tag) || GRANDFATHERED_TAGS.key?(tag.downcase)
+        end
+
+        # ==== Parameters
+        # langtag<String>:: The Language-Tag snippet.
+        #
+        # ==== Returns
+        # Array or nil::
+        #   It returns +nil+, when the Language-Tag passed:
+        #   * does not conform the Language-Tag ABNF (malformed)
+        #   * grandfathered
+        #   * starts with 'x' singleton ('privateuse').
+        #
+        #   Otherwise you'll get an +Array+ with:
+        #   * primary subtag (as +String+, downcased),
+        #   * extlang (as +String+, downcased) or +nil+,
+        #   * script (as +String+, capitalized) or +nil+,
+        #   * region (as +String+, upcased) or +nil+
+        #   * downcased variants (+Array+) or nil.
+        #
+        # ==== Notes
+        # In most cases, it's quite enough. Take a look, for example, at
+        # {'35-character recomendation'}[http://tools.ietf.org/html/rfc5646#section-4.6].
+        #
+        def extract_language_info(langtag)
+          tag = langtag.downcase
+          return nil if GRANDFATHERED_TAGS.key?(langtag)
+          return nil unless LANGTAG_INFO_REGEX === tag
+
+          primary     = $1
+          extlang     = nil
+          script      = $2
+          region      = $3
+          variants    = $4.split(Utils::HYPHEN_SPLITTER)[1..-1]
+
+          primary, extlang = primary.split(Utils::HYPHEN_SPLITTER) if primary.include?(Const::HYPHEN)
+          script.capitalize! if script
+          region.upcase! if region
+
+          [primary, extlang, script, region, variants]
+        end
+
+        def parse(thing)
+          return nil unless thing
+          return thing if thing.kind_of?(self)
+          self.new.recompose(thing)
+        end
+
+      end
+
+      # Checks if self has a variant passed.
+      # Works case-insensitively.
+      #
+      # ==== Notes
+      # *Destructively* downcases current set of variants, if necessary.
+      # Just note, that variants are case-insensitive, and 'convenient' form
+      # of the Languge-Tag assumes they're in 'lowercase' notation.
+      #
+      def has_variant?(variant)
+        return false unless @variants
+        @variants.include?(variant) || begin
+          @variants.map { |v| v.downcase! }
+          @variants.include?(variant.downcase)
+        end
+      end
+
+      # Checks if self has a singleton passed.
+      # Works case-insensitively.
+      def has_singleton?(key)
+        return false unless @extensions
+        @extensions.key?(key) || @extensions.key?(key.downcase)
+      end
+
+      alias :extension? :has_singleton?
+
+      # Builds an ordered list of singletons.
+      def singletons
+        return nil unless @extensions
+        keys = @extensions.keys
+        keys.sort!
+        keys
+      end
+
+      def initialize(*components)
+        @primary, @extlang, @script, @region, @variants, @extensions, @privateuse = *components
+      end
+
+      # Builds the +String+, which represents self.
+      # Does *not* perform validation or recomposition.
+      #
+      def compose
+        @tag = to_a.join(Const::HYPHEN)
+        @tag
+      end
+
+      attr_reader :tag # the most recent 'build' of tag
+
+      def nicecased
+        recompose   # we could not conveniently format malformed or invalid tags
+        @nicecased  #.dup #uuuuugh
+      end
+
+      def to_a
+        ary = [@primary]
+        ary << @extlang if @extlang
+        ary << @script if @script
+        ary << @region if @region
+        ary.concat @variants if @variants
+        singletons.each { |s| (ary << s).concat @extensions[s] } if @extensions
+        (ary << PRIVATEUSE).concat @privateuse if @privateuse
+        ary
+      rescue
+        raise "LanguageTag has at least one malformed attribute: #{self.inspect}"
+      end
+
+      #--
+      # RFC 4647, sec. 3.3.2 ('Extended Filtering')
+      #
+      # Much like basic filtering, extended filtering selects content with
+      # arbitrarily long tags that share the same initial subtags as the
+      # language range.  In addition, extended filtering selects language
+      # tags that contain any intermediate subtags not specified in the
+      # language range.  For example, the extended language range "de-*-DE"
+      # (or its synonym "de-DE") matches all of the following tags:
+      #
+      #   de-DE (German, as used in Germany)
+      #   de-de (German, as used in Germany)
+      #   de-Latn-DE (Latin script)
+      #   de-Latf-DE (Fraktur variant of Latin script)
+      #   de-DE-x-goethe (private-use subtag)
+      #   de-Latn-DE-1996 (orthography of 1996)
+      #   de-Deva-DE (Devanagari script)
+      #
+      # The same range does not match any of the following tags for the
+      # reasons shown:
+      #
+      #   de (missing 'DE')
+      #   de-x-DE (singleton 'x' occurs before 'DE')
+      #   de-Deva ('Deva' not equal to 'DE')
+      #++
+
+      # Checks if the *extended* Language-Range passed matches self.
+      def matched_by_extended_range?(range)
+        recompose
+        subtags = @composition.split(Const::HYPHEN)
+        subranges = range.downcase.split(Const::HYPHEN)
+
+        subrange = subranges.shift
+        subtag = subtags.shift
+
+        while subrange
+          if subrange == Const::WILDCARD
+            subrange = subranges.shift
+          elsif subtag == nil
+            return false
+          elsif subtag == subrange
+            subtag = subtags.shift
+            subrange = subranges.shift
+          elsif subtag.size == 1
+            return false
+          else
+            subtag = subtags.shift
+          end
+        end
+        true
+      rescue
+        false
+      end
+
+      #--
+      # RFC 4647, sec. 3.3.1 ('Basic Filtering')
+      #
+      # A language range matches a
+      # particular language tag if, in a case-insensitive comparison, it
+      # exactly equals the tag, or if it exactly equals a prefix of the tag
+      # such that the first character following the prefix is "-".  For
+      # example, the language-range "de-de" (German as used in Germany)
+      # matches the language tag "de-DE-1996" (German as used in Germany,
+      # orthography of 1996), but not the language tags "de-Deva" (German as
+      # written in the Devanagari script) or "de-Latn-DE" (German, Latin
+      # script, as used in Germany).
+      #++
+
+      # Checks if the *basic* Language-Range passed matches self.
+      #
+      # ==== Example
+      #   tag = LanguageTag.parse('de-Latn-DE')
+      #   tag.matched_by_basic_range?('de-Latn-DE') #=> true
+      #   tag.matched_by_basic_range?('de-Latn') #=> true
+      #   tag.matched_by_basic_range?('*') #=> true
+      #   tag.matched_by_basic_range?('de-La') #=> false
+      #   tag.matched_by_basic_range?('de-de') #=> false
+      #   tag.matched_by_basic_range?('malformedlangtag') #=> false
+      #
+      def matched_by_basic_range?(range)
+        if range.kind_of?(self.class)
+          s = range.recompose.tag
+        elsif range.respond_to?(:to_str)
+          return true if range.to_str == Const::WILDCARD
+          s = self.class.parse(range).tag
+        else
+          return false
+        end
+        recompose
+        @tag == s || @tag.index(s + Const::HYPHEN) == 0
+      rescue
+        false
+      end
+
+      alias :has_prefix? :matched_by_basic_range?
+
+      def ==(other)
+        return false unless other.kind_of?(self.class)
+        compose
+        other.compose
+        @tag == other.tag || @tag.downcase == other.tag.downcase
+      end
+
+      def ===(other)
+        if other.kind_of?(self.class)
+          s = other.compose
+        elsif other.respond_to?(:to_str)
+          s = other.to_str
+        else
+          return false
+        end
+        compose
+        @tag == s || @tag.downcase == s.downcase
+      end
+
+      # Validates self.
+      #
+      # ==== Notes
+      # Validation is deferred by default, because the paranoid
+      # check & dup of everything is not a good way (in this case).
+      # So, you may create some tags, make them malformed/invalid,
+      # and still be able to compare and modify them. Only note, that
+      # things like 'filtering' and 'lookup' are *not* validation-free.
+      #
+      def valid?
+        !!recompose rescue false
+      end
+
+      alias :langtag? :valid?
+
+      # ==== Parameters
+      # thing<String, optional>::
+      #   The Language-Tag snippet
+      #
+      # ==== Returns
+      # +self+
+      #
+      # ==== Raises
+      # ArgumentError::
+      #   The Language-Tag composition:
+      #   * does not conform the Language-Tag ABNF (malformed)
+      #   * grandfathered
+      #   * starts with 'x' singleton ('privateuse').
+      #   * contains duplicate variants
+      #   * contains duplicate singletons
+      #
+      def recompose(thing = nil)
+
+        tag = nil
+        compose
+
+        if thing
+          raise TypeError, "Can't convert #{thing.class} into String" unless thing.respond_to?(:to_str)
+          return self if @tag == (tag = thing.to_str) || @tag.downcase == (tag = tag.downcase)
+        else
+          return self if @nicecased == (tag = @tag) || @composition == tag || @composition == (tag = tag.downcase)
+        end
+
+        if !GRANDFATHERED_TAGS.key?(tag) && LANGTAG_COMPOSITION_REGEX === tag
+
+          @primary = $1
+          @extlang    = nil
+          @script     = $2
+          @region     = $3
+          components  = $'.split(Utils::HYPHEN_SPLITTER)
+          components.shift
+
+          @primary, @extlang = @primary.split(Utils::HYPHEN_SPLITTER) if @primary.include?(Const::HYPHEN)
+
+          @script.capitalize! if @script
+          @region.upcase! if @region
+
+          @extensions = nil
+          @variants   = nil
+          singleton   = nil
+
+          while c = components.shift
+            if c.size == 1
+              break if c == PRIVATEUSE
+              @extensions ||= {}
+              if @extensions.key?(c)
+                raise ArgumentError, "Invalid langtag (repeated singleton: #{c.inspect}): #{thing.inspect}"
+              end
+              singleton = c
+              @extensions[singleton = c] = []
+            elsif singleton
+              @extensions[singleton] << c
+            else
+              @variants ||= []
+              if @variants.include?(c)
+                raise ArgumentError, "Invalid langtag (repeated variant: #{c.inspect}): #{thing.inspect}"
+              end
+              @variants << c
+            end
+          end
+
+          @privateuse   = components.empty? ? nil : components
+          @nicecased    = compose
+          @composition  = @tag.downcase
+
+        else
+          raise ArgumentError, "Malformed, grandfathered or 'privateuse' Language-Tag: #{thing.inspect}"
+        end
+
+        self
+      end
+    end
+  end
+end
+
+# EOF

data/lib/rack/acceptable/middleware/fake_accept.rb

@@ -0,0 +1,28 @@
+require 'rack/request'
+require 'rack/acceptable/mimetypes'
+
+module Rack #:nodoc:
+  module Acceptable #:nodoc:
+    class FakeAccept
+
+      ORIGINAL_HTTP_ACCEPT = 'rack-acceptable.fake_accept.original_HTTP_ACCEPT'
+
+      def initialize(app, default_media = 'text/html')
+        @default_media = default_media
+        @app = app
+      end
+
+      def call(env)
+        request = ::Rack::Request.new(env)
+        extname = ::File.extname(request.path_info)
+        env[ORIGINAL_HTTP_ACCEPT] = env[Const::ENV_HTTP_ACCEPT]
+        env[Const::ENV_HTTP_ACCEPT] = Rack::Acceptable::MIMETypes.lookup(extname, @default_media)
+        @app.call(env)
+      end
+
+    end
+
+  end
+end
+
+# EOF

data/lib/rack/acceptable/middleware/formats.rb

@@ -0,0 +1,69 @@
+require 'rack/acceptable/utils'
+
+module Rack #:nodoc:
+  module Acceptable #:nodoc:
+
+    # * Fishes out all acceptable formats (in the appropriate order).
+    #   The idea is to let the user decide about the preferred one,
+    #   since the Accept request-header is not only thing the response
+    #   depends on.
+    # * Stops processing and responds with 406 'Not Acceptable' *only*
+    #   if there's no acceptable formats *and* wildcard has a zero quality
+    #   or not explicitly mentioned; i.e, decreases (slightly) the the
+    #   number of application calls in compliance with notes in
+    #   RFC 2616, sec. 10.4.7.
+    #
+    # ==== Example
+    #
+    #   @provides = {
+    #     :json => %w(text/x-json application/json),
+    #     :xml  => %w(application/xml text/xml),
+    #     :text => %w(text/plain text/*)
+    #     }
+    #
+    #   use Rack::Acceptable::Formats @provides
+    #
+    class Formats
+
+      CANDIDATES = 'rack-acceptable.formats.candidates'
+
+      #--
+      # RFC 2616, section 10.4.7:
+      # Note: HTTP/1.1 servers are allowed to return responses which are
+      # not acceptable according to the accept headers sent in the
+      # request. In some cases, this may even be preferable to sending a
+      # 406 response. User agents are encouraged to inspect the headers of
+      # an incoming response to determine if it is acceptable.
+      #++
+
+      def initialize(app, provides)
+        @app, @types = app, {}
+        provides.each { |f,types| types.each { |t| @types[t] = f } }
+        @types.update(Const::MEDIA_RANGE_WILDCARD => :all)
+      end
+
+      def call(env)
+        if accepts = env[Const::ENV_HTTP_ACCEPT]
+          accepts = Utils.extract_qvalues(accepts)
+          i = 0
+          accepts = accepts.sort_by { |_,q| [-q,i+=1] }
+          accepts.reject! { |t,q| q == 0 || !@types.key?(t) }
+          if accepts.empty?
+            return Const::NOT_ACCEPTABLE_RESPONSE
+          else
+            accepts.map! { |t,_| @types[t] }.uniq!
+            env[CANDIDATES] = accepts
+          end
+        else
+          env[CANDIDATES] = [:all]
+        end
+        @app.call(env)
+      #rescue
+      #  @app.call(env)
+      end
+
+    end
+  end
+end
+
+# EOF

data/lib/rack/acceptable/middleware/provides.rb

@@ -0,0 +1,97 @@
+require 'rack/utils'
+require 'rack/acceptable/request'
+
+module Rack #:nodoc:
+  module Acceptable #:nodoc:
+
+    # Inspired (partially) by the Rack::AcceptFormat.
+    #
+    # * Fishes out the best one of available MIME-Types.
+    # * Adds an associated format (extension) to the path_info (optional).
+    # * Stops processing and responds with 406 'Not Acceptable',
+    #   when there's nothing to provide.
+    # * Memoizes results, since the full negotiation is not
+    #   the 'week' (but quick!) lookup.
+    #
+    # ==== Example
+    #
+    #   use Rack::Acceptable::Provides w(text/x-json application/json text/plain),
+    #     :force_format   => true,
+    #     :default_format => '.txt'
+    #
+    class Provides
+
+      CANDIDATE = 'rack-acceptable.provides.candidate'
+      CANDIDATE_INFO = 'rack-acceptable.provides.candidate_info'
+
+      # ==== Parameters
+      # app<#call>:: Rack application.
+      # provides<Array>:: List of available MIME-Types.
+      # options<Hash>:: Additional options, like +negotiate_by+. See also the
+      #                 Rack::Acceptable::MIMETypes#detect_best_mime_type method.
+      #
+      def initialize(app, provides, options = {})
+        raise "You should provide the list of available MIME-Types." if provides.empty?
+        @app = app
+        @provides = provides.map { |type| MIMETypes.parse_media_range(type) << type }
+        @provides << (options[:negotiate_by] == :qvalue_only ? true : false)
+        @lookup = {}
+        @force_format = !!options[:force_format]
+        if @force_format && options.key?(:default_format)
+          ext = options[:default_format].to_s.strip
+          @_extension = ext[0] == ?. ? ext : ".#{ext}" unless ext.empty?
+        end
+      end
+
+      def call(env)
+        request = Rack::Acceptable::Request.new(env)
+        return Const::NOT_ACCEPTABLE_RESPONSE unless preferred = _negotiate(request)
+
+        simple = preferred.last
+        request.env[CANDIDATE] = simple
+        request.env[CANDIDATE_INFO] = preferred[0..2]
+
+        if @force_format &&
+          (path = request.path_info) != Const::SLASH &&
+          ext = _extension_for(simple)
+          request.path_info = path.sub(/\/*$/, ext)
+        end
+
+        status, headers, body = @app.call(env)
+        unless Rack::Utils::STATUS_WITH_NO_ENTITY_BODY.include?(status.to_i)
+          headers = Rack::Utils::HeaderHash.new(headers)
+          headers[Const::CONTENT_TYPE] ||= simple
+        end
+        [status, headers.to_hash, body]
+      end
+
+      private
+
+      # Picks out an extension for the MIME-Type given.
+      # Override this to force the usage of another MIME-Type registry.
+      # See Rack::Acceptable::MIMETypes about the manipulating with
+      # entries in the registry.
+      #
+      def _extension_for(thing)
+        MIMETypes.extension_for(thing) || @_extension
+      end
+
+      # Performs negotiation and memoizes result.
+      #
+      def _negotiate(request)
+        header = request.env[Const::ENV_HTTP_ACCEPT]
+        if @lookup.key?(header)
+          @lookup[header]
+        else
+          accepts = request.acceptable_media
+          @lookup[header] = accepts.empty? ? @provides.first : request.preferred_media_from(*@provides)
+        end
+      rescue
+        @lookup[header] = nil # The Accept request-header is malformed.
+      end
+
+    end
+  end
+end
+
+# EOF