gnarly 0.0.1

data/lib/gnarly/application.rb

@@ -0,0 +1,105 @@
+require 'gnarly/url.rb'
+require 'gnarly/request.rb'
+require 'gnarly/mimeparse.rb'
+
+module Gnarly
+
+  class Application
+
+    def initialize()
+      @urls = []
+    end
+
+    def url(url_mask, &block)
+      url = Url.new(url_mask)
+      url.instance_eval &block
+      @urls << url
+    end
+
+    def environment()
+      @environment
+    end
+
+    def request()
+      @request
+    end
+
+    def ok(body, mime=nil)
+      headers = mime ? {"Content-type" => mime} : {}
+      [200, headers, [body]]
+    end
+
+    def not_found(body="Not Found", mime="text/plain")
+      [404, {"Content-type" => mime}, [body]]
+    end
+
+    def method_not_allowed(allow, body="Method Not Allowed", mime="text/plain")
+      [405,
+       {"Content-type" => mime, "Allow" => allow},
+       [body]]
+    end
+
+    def not_acceptable(acceptable=nil, body=nil, mime="text/plain")
+      body = "" unless body
+      [406,
+       {"Content-type" => mime},
+       [body]]
+    end
+
+    def internal_server_error(body="Internal Server Error", mime="text/plain")
+      [500, {"Content-type" => mime}, [body]]      
+    end
+
+    def provides(*mimes, &block)
+      mime = MIMEParse.best_match mimes, request.accept
+      if mime
+        response = block.call mime if block
+        if response.is_a? Array and response.size == 3
+          status, headers, body = response
+          unless headers.key? "Content-type"
+            charset = body_charset(body)
+            headers["Content-type"] = 
+              charset ? "#{mime}; charset=#{charset}" : mime
+          end
+          response
+        else
+          name, line = @responder.source_location
+          msg = "Bad return type for block in  #{filename} line #{line}"
+          internal_server_error msg
+        end
+      else
+        not_acceptable
+      end
+    end
+
+    def call(env)
+      @request = Request.new env
+      @environment = env
+      path = env["PATH_INFO"]
+      if url = @urls.detect { |u| u.match? path }
+        method = env["REQUEST_METHOD"]
+        @responder = url.responder method
+        if @responder
+          instance_exec *url.parameters, &@responder
+        else
+          method_not_allowed url.allow
+        end
+      else
+        not_found
+      end
+    end
+
+    private
+
+    def body_charset(body)
+      charset = nil
+      body.each do |s|
+        charset = s.encoding.to_s
+        break
+      end
+      charset
+    end
+
+  end
+
+end

data/lib/gnarly/mimeparse.rb

@@ -0,0 +1,216 @@
+# mimeparse.rb
+#
+# This module provides basic functions for handling mime-types. It can
+# handle matching mime-types against a list of media-ranges. See section
+# 14.1 of the HTTP specification [RFC 2616] for a complete explanation.
+#
+#   http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.1
+#
+# ---------
+#
+# This is a port of Joe Gregario's mimeparse.py, which can be found at 
+#   <http://code.google.com/p/mimeparse/>.
+#
+# ported from version 0.1.2
+#
+# Comments are mostly excerpted from the original.
+
+module MIMEParse
+  module_function
+
+# Carves up a mime-type and returns an Array of the
+#  [type, subtype, params] where "params" is a Hash of all
+#  the parameters for the media range.
+#
+# For example, the media range "application/xhtml;q=0.5" would
+#  get parsed into:
+#
+# ["application", "xhtml", { "q" => "0.5" }]
+def parse_mime_type(mime_type)
+  parts = mime_type.split(";")
+
+  params = {}
+
+  parts[1..-1].map do |param|
+    k,v = param.split("=").map { |s| s.strip }
+    params[k] = v
+  end
+
+  full_type = parts[0].strip
+  # Java URLConnection class sends an Accept header that includes a single "*"
+  # Turn it into a legal wildcard.
+  full_type = "*/*" if full_type == "*"
+  type, subtype = full_type.split("/")
+  raise "malformed mime type" unless subtype
+
+  [type.strip, subtype.strip, params]
+end
+
+# Carves up a media range and returns an Array of the
+#  [type, subtype, params] where "params" is a Hash of all
+#  the parameters for the media range.
+#
+# For example, the media range "application/*;q=0.5" would
+#  get parsed into:
+#
+# ["application", "*", { "q", "0.5" }]
+#
+# In addition this function also guarantees that there
+#  is a value for "q" in the params dictionary, filling it
+#  in with a proper default if necessary.
+def parse_media_range(range)
+  type, subtype, params = parse_mime_type(range)
+  unless params.has_key?("q") and params["q"] and params["q"].to_f and params["q"].to_f <= 1 and params["q"].to_f >= 0
+    params["q"] = "1"
+  end
+
+  [type, subtype, params]
+end
+
+# Find the best match for a given mime-type against a list of
+#  media_ranges that have already been parsed by #parse_media_range
+#
+# Returns the fitness and the "q" quality parameter of the best match,
+#  or [-1, 0] if no match was found. Just as for #quality_parsed,
+#  "parsed_ranges" must be an Enumerable of parsed media ranges.
+def fitness_and_quality_parsed(mime_type, parsed_ranges)
+  best_fitness = -1
+  best_fit_q = 0
+  target_type, target_subtype, target_params = parse_media_range(mime_type)
+
+  parsed_ranges.each do |type,subtype,params|
+    if (type == target_type or type == "*" or target_type == "*") and
+        (subtype == target_subtype or subtype == "*" or target_subtype == "*")
+      param_matches = target_params.find_all { |k,v| k != "q" and params.has_key?(k) and v == params[k] }.length
+
+      fitness = (type == target_type) ? 100 : 0
+      fitness += (subtype == target_subtype) ? 10 : 0
+      fitness += param_matches
+
+      if fitness > best_fitness
+        best_fitness = fitness
+        best_fit_q = params["q"]
+      end
+    end
+  end
+
+  [best_fitness, best_fit_q.to_f]
+end
+
+# Find the best match for a given mime-type against a list of
+#  media_ranges that have already been parsed by #parse_media_range
+#
+# Returns the "q" quality parameter of the best match, 0 if no match
+#  was found. This function behaves the same as #quality except that
+#  "parsed_ranges" must be an Enumerable of parsed media ranges.
+def quality_parsed(mime_type, parsed_ranges)
+  fitness_and_quality_parsed(mime_type, parsed_ranges)[1]
+end
+
+# Returns the quality "q" of a mime_type when compared against
+#  the media-ranges in ranges. For example:
+#
+#     irb> quality("text/html", "text/*;q=0.3, text/html;q=0.7, text/html;level=1, text/html;level=2;q=0.4, */*;q=0.5")
+#     => 0.7
+def quality(mime_type, ranges)
+  parsed_ranges = ranges.split(",").map { |r| parse_media_range(r) }
+  quality_parsed(mime_type, parsed_ranges)
+end
+
+# Takes a list of supported mime-types and finds the best match
+#  for all the media-ranges listed in header. The value of header
+#  must be a string that conforms to the format of the HTTP Accept:
+#  header. The value of supported is an Enumerable of mime-types
+#
+#     irb> best_match(["application/xbel+xml", "text/xml"], "text/*;q=0.5,*/*; q=0.1")
+#     => "text/xml"
+def best_match(supported, header)
+  parsed_header = header.split(",").map { |r| parse_media_range(r) }
+
+  weighted_matches = supported.map do |mime_type|
+    [fitness_and_quality_parsed(mime_type, parsed_header), mime_type]
+  end
+
+  weighted_matches.sort!
+
+  weighted_matches.last[0][1].zero? ? nil : weighted_matches.last[1]
+end
+end
+
+if __FILE__ == $0
+  require "test/unit"
+
+  class TestMimeParsing < Test::Unit::TestCase
+    include MIMEParse
+
+    def test_parse_media_range
+      assert_equal [ "application", "xml", { "q" => "1" } ],
+                    parse_media_range("application/xml;q=1")
+
+      assert_equal [ "application", "xml", { "q" => "1" } ],
+                    parse_media_range("application/xml")
+
+      assert_equal [ "application", "xml", { "q" => "1" } ],
+                    parse_media_range("application/xml;q=")
+
+      assert_equal [ "application", "xml", { "q" => "1", "b" => "other" } ],
+                    parse_media_range("application/xml ; q=1;b=other")
+
+      assert_equal [ "application", "xml", { "q" => "1", "b" => "other" } ],
+                    parse_media_range("application/xml ; q=2;b=other")
+
+      # Java URLConnection class sends an Accept header that includes a single "*"
+      assert_equal [ "*", "*", { "q" => ".2" } ],
+                    parse_media_range(" *; q=.2")
+    end
+
+    def test_rfc_2616_example
+      accept = "text/*;q=0.3, text/html;q=0.7, text/html;level=1, text/html;level=2;q=0.4, */*;q=0.5"
+
+      assert_equal 1, quality("text/html;level=1", accept)
+      assert_equal 0.7, quality("text/html", accept)
+      assert_equal 0.3, quality("text/plain", accept)
+      assert_equal 0.5, quality("image/jpeg", accept)
+      assert_equal 0.4, quality("text/html;level=2", accept)
+      assert_equal 0.7, quality("text/html;level=3", accept)
+    end
+
+    def test_best_match
+      @supported_mime_types = [ "application/xbel+xml", "application/xml" ]
+
+      # direct match
+      assert_best_match "application/xbel+xml", "application/xbel+xml"
+      # direct match with a q parameter
+      assert_best_match "application/xbel+xml", "application/xbel+xml; q=1"
+      # direct match of our second choice with a q parameter
+      assert_best_match "application/xml", "application/xml; q=1"
+      # match using a subtype wildcard
+      assert_best_match "application/xml", "application/*; q=1"
+      # match using a type wildcard
+      assert_best_match "application/xml", "*/*"
+
+      @supported_mime_types = [ "application/xbel+xml", "text/xml" ]
+      # match using a type versus a lower weighted subtype
+      assert_best_match "text/xml", "text/*;q=0.5,*/*;q=0.1"
+      # fail to match anything
+      assert_best_match nil, "text/html,application/atom+xml; q=0.9"
+      # common AJAX scenario
+      @supported_mime_types = [ "application/json", "text/html" ]
+      assert_best_match "application/json", "application/json, text/javascript, */*"
+      # verify fitness sorting
+      assert_best_match "application/json", "application/json, text/html;q=0.9"
+    end
+
+    def test_support_wildcards
+      @supported_mime_types = ['image/*', 'application/xml']
+      # match using a type wildcard
+      assert_best_match 'image/*', 'image/png'
+      # match using a wildcard for both requested and supported
+      assert_best_match 'image/*', 'image/*'
+    end
+
+    def assert_best_match(expected, header)
+      assert_equal(expected, best_match(@supported_mime_types, header))
+    end
+  end
+end

data/lib/gnarly/request.rb

@@ -0,0 +1,45 @@
+
+module Gnarly
+
+  class Request
+
+    def initialize(env)
+      @environment = env
+      parse_content_type
+    end
+
+    def accept()
+      @accept ||= @environment["HTTP_ACCEPT"]
+    end
+
+    def content_type()
+      @content_type
+    end
+
+    def charset()
+      @charset
+    end
+
+    def body()
+      unless @body
+        input = @environment["rack.input"]
+        @body = input.read
+        input.rewind
+        @body.force_encoding charset if charset
+      end
+      @body
+    end
+
+    private
+
+    def parse_content_type()
+      if header = @environment["CONTENT_TYPE"]
+        header =~ /^([^;\s]+)(\s*;\s*charset=(\S+)\s*)$/
+        @content_type = $1
+        @charset = $3
+      end
+    end
+
+  end
+
+end

data/lib/gnarly/url.rb

@@ -0,0 +1,53 @@
+
+module Gnarly
+
+  class Url
+
+    def initialize(url_mask)
+      @url_mask = url_mask
+      @responders = {}
+      @allow = []
+    end
+
+    def match?(path)
+      @match = @url_mask.match path
+      @match != nil
+    end
+
+    def parameters()
+      a = @match.to_a
+      a.shift
+      a
+    end
+
+    def responder(method)
+      @responders[method]
+    end
+
+    def allow()
+      @allow.join " "
+    end
+
+    def get(&block)
+      @responders["GET"] = block
+      @allow << "GET"
+    end
+
+    def put(&block)
+      @responders["PUT"] = block
+      @allow << "PUT"
+    end
+
+    def post(&block)
+      @responders["POST"] = block
+      @allow << "POST"
+    end
+
+    def delete(&block)
+      @responders["DELETE"] = block
+      @allow << "DELETE"
+    end
+
+  end
+
+end

data/lib/gnarly.rb

@@ -0,0 +1,11 @@
+require 'gnarly/application.rb'
+
+module Gnarly
+
+  def self.application(&block)
+    app = Application.new
+    app.instance_eval &block
+    app
+  end
+
+end

metadata

@@ -0,0 +1,66 @@
+--- !ruby/object:Gem::Specification 
+name: gnarly
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Kim Dalsgaard
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-02-24 00:00:00 +01:00
+default_executable: 
+dependencies: []
+
+description: Super simple DSL style web framework on top of Rack. Makes real HTTP'ish REST services easy.
+email: kim@kimdalsgaard.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/gnarly/application.rb
+- lib/gnarly/mimeparse.rb
+- lib/gnarly/request.rb
+- lib/gnarly/url.rb
+- lib/gnarly.rb
+has_rdoc: true
+homepage: 
+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: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: Super simple web framework on top of Rack
+test_files: []
+