acceptable 0.2.1

data/lib/rack/acceptable/utils.rb

@@ -0,0 +1,231 @@
+# encoding: binary
+
+require 'rack/acceptable/const'
+
+module Rack #:nodoc:
+  module Acceptable #:nodoc:
+    module Utils
+
+      #--
+      # http://tools.ietf.org/html/rfc2616#section-2.1
+      # http://tools.ietf.org/html/rfc2616#section-2.2
+      # http://tools.ietf.org/html/rfc2616#section-3.9
+      #++
+
+      QUALITY_PATTERN     = '\s*(?:;\s*q=(0(?:\.\d{0,3})?|1(?:\.0{0,3})?))?'.freeze
+      QVALUE_REGEX        = /\A(?:0(?:\.\d{0,3})?|1(?:\.0{0,3})?)\z/.freeze
+      QUALITY_REGEX       = /\s*;\s*q\s*=([^;\s]*)/i.freeze
+
+      QVALUE_DEFAULT      = 1.00
+      QVALUE              = 'q'.freeze
+
+      # see benchmarks/simple/split_bench.rb
+      if RUBY_VERSION < '1.9.1'
+
+        PAIR_SPLITTER       = /\=/.freeze
+        HYPHEN_SPLITTER     = /-/
+        COMMA_SPLITTER      = /,/
+        SEMICOLON_SPLITTER  = /;/.freeze
+
+      else
+
+        PAIR_SPLITTER       = '='.freeze
+        HYPHEN_SPLITTER     = Const::HYPHEN
+        COMMA_SPLITTER      = Const::COMMA
+        SEMICOLON_SPLITTER  = Const::SEMICOLON
+
+      end
+
+      COMMA_WS_SPLITTER   = /,\s*/.freeze
+      TOKEN_PATTERN       = "[A-Za-z0-9#{Regexp.escape('!#$&%\'*+-.^_`|~')}]+".freeze
+
+      module_function
+
+      # ==== Parameters
+      # header<String>:: 
+      #   The 'Accept' request-header, one of: 
+      #   * Accept
+      #   * Accept-Charset
+      #   * Accept-Encoding
+      #   * Accept-Language
+      #
+      # ==== Returns
+      # Result of parsing. An Array with entries (as a +Strings+) and
+      # associated quality factors (qvalues). Default qvalue is 1.0.
+      #
+      # ==== Raises
+      # ArgumentError:: There's a malformed qvalue in header.
+      #
+      # ==== Notes
+      # * It checks *only* quality factors (full syntactical inspection of
+      #   the HTTP header is *not* a task of simple qvalues extractor).
+      # * It does *not* perform additional operations (downcase etc),
+      #   thereto a bunch of more specific parsers is provided.
+      #
+      def extract_qvalues(header)
+        header.split(COMMA_WS_SPLITTER).map! { |entry|
+          QUALITY_REGEX === entry
+          thing = $` || entry
+          if !(qvalue = $1)
+            [thing, QVALUE_DEFAULT]
+          elsif QVALUE_REGEX === qvalue
+            [thing, qvalue.to_f]
+          else
+            raise ArgumentError, "Malformed quality factor: #{qvalue.inspect}"
+          end
+        }
+      end
+
+      #:stopdoc:
+
+      def parse_header(header, regex)
+        header.split(COMMA_SPLITTER).map! do |entry|
+          raise unless regex === entry
+          [$1, ($2 || QVALUE_DEFAULT).to_f]
+        end
+      end
+
+      #:startdoc:
+
+      HTTP_ACCEPT_TOKEN_REGEX = /^\s*(#{Utils::TOKEN_PATTERN})#{Utils::QUALITY_PATTERN}\s*$/o.freeze
+
+      module_function
+
+      # ==== Parameters
+      # provides<Array>:: The Array of available Content-Codings. Could be empty.
+      # accepts<Array>:: The Array of acceptable Content-Codings. Could be empty.
+      #
+      # ==== Returns
+      # The best one of available Content-Codings (as a +String+) or +nil+.
+      #
+      # ==== Notes
+      # Available and acceptable Content-Codings are supposed to be *downcased*
+      # According to section 3.5 of RFC 2616, Content-Codings are *case-insensitive*.
+      #
+      def detect_best_encoding(provides, accepts)
+        return nil if provides.empty?
+
+        identity = provides.include?(Const::IDENTITY) # presence of 'identity' in available content-codings
+        identity_or_wildcard = true # absence of explicit 'identity;q=0' or '*;q=0'
+
+        # RFC 2616, sec. 14.3:
+        # If no Accept-Encoding field is present in a request, the server
+        # MAY assume that the client will accept any content coding. In this
+        # case, if "identity" is one of the available content-codings, then
+        # the server SHOULD use the "identity" content-coding, unless it has
+        # additional information that a different content-coding is meaningful
+        # to the client.
+
+        return Const::IDENTITY if identity && accepts.empty?
+        #return (identity ? Const::IDENTITY : provides.first) if accepts.empty?
+
+        # RFC 2616, sec. 14.3:
+        # The "identity" content-coding is always acceptable, unless
+        # specifically refused because the Accept-Encoding field includes
+        # "identity;q=0", or because the field includes "*;q=0" and does
+        # not explicitly include the "identity" content-coding. If the
+        # Accept-Encoding field-value is empty, then only the "identity"
+        # encoding is acceptable.
+
+        candidates = []
+        expansion = nil
+        i = 0
+
+        accepts.sort_by { |_,q| [-q,i+=1] }.each do |c,q|
+          if q == 0
+            identity_or_wildcard = false if c == Const::IDENTITY || c == Const::WILDCARD
+          elsif c == Const::WILDCARD
+            expansion ||= provides - accepts.map { |c| c.first }
+            candidates.concat expansion
+          else
+            candidates << c
+          end
+        end
+
+        (candidates & provides).first ||
+        (Const::IDENTITY if identity && identity_or_wildcard) ||
+        nil
+      end
+
+      # ==== Parameters
+      # provides<Array>:: The Array of available Charsets. Could be empty.
+      # accepts<Array>:: The Array of acceptable Charsets. Could be empty.
+      #
+      # ==== Returns
+      # The best one of available Charsets (as a +String+) or +nil+.
+      #
+      # ==== Notes
+      # Available and acceptable Charsets are supposed to be *downcased*.
+      # According to section 3.4 of RFC 2616, Charsets are *case-insensitive*.
+      #
+      def detect_best_charset(provides, accepts)
+        return nil if provides.empty?
+
+        # RFC 2616, sec 14.2:
+        # If no Accept-Charset header is present, the default is that any
+        # character set is acceptable. If an Accept-Charset header is present,
+        # and if the server cannot send a response which is acceptable
+        # according to the Accept-Charset header, then the server SHOULD send
+        # an error response with the 406 (not acceptable) status code, though
+        # the sending of an unacceptable response is also allowed.
+
+        return provides.first if accepts.empty?
+
+        expansion = nil
+        candidates = []
+        i = 0
+
+        accepts << [Const::ISO_8859_1, 1.0] unless accepts.assoc(Const::ISO_8859_1) || accepts.assoc(Const::WILDCARD)
+
+        accepts.sort_by { |_,q| [-q,i+=1] }.each do |c,q|
+
+          next if q == 0
+
+          if c == Const::WILDCARD
+
+            # RFC 2616, sec 14.2:
+            # The special value "*", if present in the Accept-Charset field,
+            # matches every character set (including ISO-8859-1) which is not
+            # mentioned elsewhere in the Accept-Charset field. If no "*" is present
+            # in an Accept-Charset field, then all character sets not explicitly
+            # mentioned get a quality value of 0, except for ISO-8859-1, which gets
+            # a quality value of 1 if not explicitly mentioned.
+
+            expansion ||= provides - accepts.map { |c,_| c }
+            candidates.concat expansion
+          else
+            candidates << c
+          end
+        end
+
+        (candidates & provides).first
+      end
+
+      #--
+      # RFC 2616, sec. 3.10:
+      # White space is not allowed within the tag and all tags are case-
+      # insensitive.
+      #
+      # RFC 4647, sec. 2.1
+      # Note that the ABNF [RFC4234] in [RFC2616] is incorrect, since it disallows the
+      # use of digits anywhere in the 'language-range' (see [RFC2616errata]).
+      #++
+
+      HTTP_ACCEPT_LANGUAGE_REGEX = /^\s*(\*|[a-z]{1,8}(?:-[a-z\d]{1,8}|-\*)*)#{Utils::QUALITY_PATTERN}\s*$/io.freeze
+
+      def normalize_header(header)
+        ret = header.strip
+        ret.gsub!(/\s*(?:,\s*)+/, Const::COMMA)
+        ret.gsub!(/^,|,$/, Const::EMPTY_STRING)
+        ret
+      end
+
+      def blank?(s)
+        s.empty? || s.strip.empty?
+      end
+
+    end
+  end
+end
+
+# EOF

data/lib/rack/acceptable/version.rb

@@ -0,0 +1,7 @@
+module Rack #:nodoc:
+  module Acceptable #:nodoc:
+    VERSION = '0.2.1'
+  end
+end
+
+# EOF

data/lib/rack/acceptable.rb

@@ -0,0 +1,27 @@
+require 'rubygems'
+gem 'rack', '>=1.0.0'
+require 'rack'
+
+module Rack #:nodoc:
+  module Acceptable
+
+    # common
+    autoload :Const           , 'rack/acceptable/const'
+    autoload :Utils           , 'rack/acceptable/utils'
+    autoload :MIMETypes       , 'rack/acceptable/mimetypes'
+    autoload :LanguageTag     , 'rack/acceptable/language_tag'
+
+    # request and mixins
+    autoload :Headers         , 'rack/acceptable/mixin/headers'
+    autoload :Media           , 'rack/acceptable/mixin/media'
+    autoload :Request         , 'rack/acceptable/request'
+
+    # middleware
+    autoload :Formats         , 'rack/acceptable/middleware/formats'
+    autoload :Provides        , 'rack/acceptable/middleware/provides'
+    autoload :FakeAccept      , 'rack/acceptable/middleware/fake_accept'
+
+  end
+end
+
+# EOF

metadata

@@ -0,0 +1,88 @@
+--- !ruby/object:Gem::Specification 
+name: acceptable
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 2
+  - 1
+  version: 0.2.1
+platform: ruby
+authors: 
+- SSDany
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-04-16 00:00:00 +04:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rack
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 0
+        - 0
+        version: 1.0.0
+  type: :runtime
+  version_requirements: *id001
+description: HTTP Accept parsers for Rack.
+email: inadsence@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+files: 
+- README.rdoc
+- lib/rack/acceptable/const.rb
+- lib/rack/acceptable/language_tag.rb
+- lib/rack/acceptable/middleware/formats.rb
+- lib/rack/acceptable/middleware/provides.rb
+- lib/rack/acceptable/middleware/fake_accept.rb
+- lib/rack/acceptable/mimetypes.rb
+- lib/rack/acceptable/mixin/headers.rb
+- lib/rack/acceptable/mixin/media.rb
+- lib/rack/acceptable/request.rb
+- lib/rack/acceptable/utils.rb
+- lib/rack/acceptable/version.rb
+- lib/rack/acceptable.rb
+- lib/rack/acceptable/data/mime.types
+has_rdoc: true
+homepage: http://github.com/SSDany/rack-acceptable
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: acceptable
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: HTTP Accept parsers for Rack.
+test_files: []
+