webmachine 0.1.0 → 0.2.0

data/lib/webmachine/decision/fsm.rb

@@ -52,15 +52,7 @@ module Webmachine
           Webmachine.render_error(code, request, response)
         when 304
           response.headers.delete('Content-Type')
-          if etag = resource.generate_etag
-            response.headers['ETag'] = ensure_quoted_header(etag)
-          end
-          if expires = resource.expires
-            response.headers['Expires'] = expires.httpdate
-          end
-          if modified = resource.last_modified
-            response.headers['Last-Modified'] = modified.httpdate
-          end
+          add_caching_headers
         end
         response.code = code
         resource.finish_request

data/lib/webmachine/decision/helpers.rb

@@ -1,4 +1,6 @@
 require 'webmachine/streaming'
+require 'webmachine/media_type'
+
 module Webmachine
   module Decision
     # Methods that assist the Decision {Flow}.
@@ -28,11 +30,19 @@ module Webmachine
                           resource.send(encoder, resource.send(charsetter, body))
                         when Enumerable
                           EnumerableEncoder.new(resource, encoder, charsetter, body)
-                        when body.respond_to?(:call)
-                          CallableEncoder.new(resource, encoder, charsetter, body)
                         else
-                          resource.send(encoder, resource.send(charsetter, body))
+                          if body.respond_to?(:call)
+                            CallableEncoder.new(resource, encoder, charsetter, body)
+                          else
+                            resource.send(encoder, resource.send(charsetter, body))
+                          end
                         end
+        if String === response.body
+          response.headers['Content-Length'] = response.body.respond_to?(:bytesize) ? response.body.bytesize.to_s : response.body.length.to_s
+        else
+          response.headers.delete 'Content-Length'
+          response.headers['Transfer-Encoding'] = 'chunked'
+        end
       end
 
       # Ensures that a header is quoted (like ETag)
@@ -55,10 +65,8 @@ module Webmachine
 
       # Assists in receiving request bodies
       def accept_helper
-        content_type = request.content_type || 'application/octet-stream'
-        mt = Conneg::MediaType.parse(content_type)
-        metadata['mediaparams'] = mt.params
-        acceptable = resource.content_types_accepted.find {|ct, _| mt.type_matches?(Conneg::MediaType.parse(ct)) }
+        content_type = MediaType.parse(request.content_type || 'application/octet-stream')
+        acceptable = resource.content_types_accepted.find {|ct, _| content_type.match?(ct) }
         if acceptable
           resource.send(acceptable.last)
         else
@@ -75,6 +83,18 @@ module Webmachine
           v.unshift "Accept" if resource.content_types_provided.size > 1
         end
       end
+
+      def add_caching_headers
+        if etag = resource.generate_etag
+          response.headers['ETag'] = ensure_quoted_header(etag)
+        end
+        if expires = resource.expires
+          response.headers['Expires'] = expires.httpdate
+        end
+        if modified = resource.last_modified
+          response.headers['Last-Modified'] = modified.httpdate
+        end
+      end
     end
   end
 end

data/lib/webmachine/errors.rb

@@ -12,6 +12,7 @@ module Webmachine
   # @param [Hash] options keys to override the defaults when rendering
   #     the response body
   def self.render_error(code, req, res, options={})
+    res.code = code
     unless res.body
       title, message = t(["errors.#{code}.title", "errors.#{code}.message"],
                          { :method => req.method,

data/lib/webmachine/headers.rb

@@ -1,16 +1,25 @@
 module Webmachine
-  # Case-insensitive Hash of request headers
+  # Case-insensitive Hash of Request headers
   class Headers < ::Hash
     def [](key)
-      super key.to_s.downcase
+      super transform_key(key)
     end
 
     def []=(key,value)
-      super key.to_s.downcase, value
+      super transform_key(key), value
     end
 
+    def delete(key)
+      super transform_key(key)
+    end
+    
     def grep(pattern)
       self.class[select { |k,_| pattern === k }]
     end
+
+    private
+    def transform_key(key)
+      key.to_s.downcase
+    end
   end
 end

data/lib/webmachine/locale/en.yml

@@ -19,10 +19,10 @@ en:
         message: "The server does not support the %{method} method."
       "503":
         title: 503 Service Unavailable
-        message: The server is currently unable to handl the request due to a temporary overloading or maintenance of the server.
+        message: The server is currently unable to handle the request due to a temporary overloading or maintenance of the server.
     create_path_nil: "post_is_create? returned true but create_path is nil! Define the create_path method in %{class}"
     do_redirect: "Response had do_redirect but no Location header."
     fsm_broke: "Decision FSM returned an unexpected value %{result} from decision %{state}."
-    invalid_media_type: "Invalid media type specified in Accept header: %{type}"
+    invalid_media_type: "Invalid media type: %{type}"
     not_resource_class: "%{class} is not a subclass of Webmachine::Resource"
     process_post_invalid: "process_post returned %{result}"

data/lib/webmachine/media_type.rb

@@ -0,0 +1,117 @@
+require 'webmachine/translation'
+
+module Webmachine
+  # Encapsulates a MIME media type, with logic for matching types.
+  class MediaType
+    extend Translation
+    # Matches valid media types
+    MEDIA_TYPE_REGEX = /^\s*([^;\s]+)\s*((?:;\s*\S+\s*)*)\s*$/
+
+    # Matches sub-type parameters
+    PARAMS_REGEX = /;\s*([^=]+)=([^;=\s]+)/
+
+    # Creates a new MediaType by parsing an alternate representation.
+    # @param [MediaType, String, Array<String,Hash>] obj the raw type
+    #   to be parsed
+    # @return [MediaType] the parsed media type
+    # @raise [ArgumentError] when the type could not be parsed
+    def self.parse(obj)
+      case obj
+      when MediaType
+        obj
+      when MEDIA_TYPE_REGEX
+        type, raw_params = $1, $2
+        params = Hash[raw_params.scan(PARAMS_REGEX)]
+        new(type, params)
+      else
+        unless Array === obj && String === obj[0] && Hash === obj[1]
+          raise ArgumentError, t('invalid_media_type', :type => obj.inspect)
+        end
+        type = parse(obj[0])
+        type.params.merge!(obj[1])
+        type
+      end
+    end
+
+    # @return [String] the MIME media type
+    attr_accessor :type
+
+    # @return [Hash] any type parameters, e.g. charset
+    attr_accessor :params
+
+    # @param [String] type the main media type, e.g. application/json
+    # @param [Hash] params the media type parameters
+    def initialize(type, params={})
+      @type, @params = type, params
+    end
+
+    # Detects whether the {MediaType} represents an open wildcard
+    # type, that is, "*/*" without any {#params}.
+    def matches_all?
+      @type == "*/*" && @params.empty?
+    end
+
+    def ==(other)
+      other = self.class.parse(other)
+      other.type == type && other.params == params
+    end
+
+    # Detects whether this {MediaType} matches the other {MediaType},
+    # taking into account wildcards. Sub-type parameters are treated
+    # strictly.
+    # @param [MediaType, String, Array<String,Hash>] other the other type 
+    # @return [true,false] whether it is an acceptable match
+    def exact_match?(other)
+      other = self.class.parse(other)
+      type_matches?(other) && other.params == params
+    end
+
+    # Detects whether the {MediaType} is an acceptable match for the
+    # other {MediaType}, taking into account wildcards and satisfying
+    # all requested parameters, but allowing this type to have extra
+    # specificity.
+    # @param [MediaType, String, Array<String,Hash>] other the other type 
+    # @return [true,false] whether it is an acceptable match
+    def match?(other)
+      other = self.class.parse(other)
+      type_matches?(other) && params_match?(other.params)
+    end
+
+    # Detects whether the passed sub-type parameters are all satisfied
+    # by this {MediaType}. The receiver is allowed to have other
+    # params than the ones specified, but all specified must be equal.
+    # @param [Hash] params the requested params
+    # @return [true,false] whether it is an acceptable match
+    def params_match?(other)
+      other.all? {|k,v| params[k] == v }
+    end
+    
+    # Reconstitutes the type into a String
+    # @return [String] the type as a String
+    def to_s
+      [type, *params.map {|k,v| "#{k}=#{v}" }].join(";")
+    end
+
+    # @return [String] The major type, e.g. "application", "text", "image"
+    def major
+      type.split("/").first
+    end
+
+    # @return [String] the minor or sub-type, e.g. "json", "html", "jpeg"
+    def minor
+      type.split("/").last
+    end
+
+    # @param [MediaType] other the other type
+    # @return [true,false] whether the main media type is acceptable,
+    #   ignoring params and taking into account wildcards
+    def type_matches?(other)
+      other = self.class.parse(other)
+      if ["*", "*/*", type].include?(other.type)
+        true
+      else
+        other.major == major && other.minor == "*"
+      end
+    end
+  end
+end

data/lib/webmachine/resource/callbacks.rb

@@ -239,6 +239,15 @@ module Webmachine
         []
       end
 
+      # This should receive the chosen language and do something with
+      # it that is resource-specific. The default is to store the
+      # value in the @language instance variable.
+      # @param [String] lang the negotiated language
+      # @api callback
+      def language_chosen(lang)
+        @language = lang
+      end
+      
       # This should return a hash of encodings mapped to encoding
       # methods for Content-Encodings your resource wants to
       # provide. The encoding will be applied to the response body

data/lib/webmachine/streaming.rb

@@ -9,15 +9,15 @@ module Webmachine
     include Enumerable
 
     def each
-      body.each do |block|
-        yield @resource.send(@encoder, resource.send(@charsetter, block))
+      @body.each do |block|
+        yield @resource.send(@encoder, @resource.send(@charsetter, block))
       end
     end
   end
 
   class CallableEncoder < StreamingEncoder
     def call
-      @resource.send(@encoder, @resource.send(@charsetter, body.call))
+      @resource.send(@encoder, @resource.send(@charsetter, @body.call))
     end
 
     def to_proc

data/lib/webmachine/version.rb

@@ -1,4 +1,4 @@
 module Webmachine
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
   SERVER_STRING = "Webmachine-Ruby/#{VERSION}"
 end

data/lib/webmachine.rb

@@ -1,3 +1,4 @@
+require 'webmachine/configuration'
 require 'webmachine/headers'
 require 'webmachine/request'
 require 'webmachine/response'
@@ -14,6 +15,7 @@ require 'webmachine/version'
 module Webmachine
   # Starts Webmachine serving requests
   def self.run
-    Adapters.const_get(adapter).run
+    configure unless configuration
+    Adapters.const_get(configuration.adapter).run
   end
 end

data/pkg/webmachine-0.1.0/Gemfile

@@ -0,0 +1,16 @@
+source :rubygems
+
+gemspec
+
+gem 'bundler'
+
+unless ENV['TRAVIS']
+  gem 'guard-rspec'
+  gem 'rb-fsevent'
+  gem 'growl'
+  gem 'growl_notify'
+end
+
+platforms :jruby do
+  gem 'jruby-openssl'
+end

data/pkg/webmachine-0.1.0/Guardfile

@@ -0,0 +1,11 @@
+gemset = ENV['RVM_GEMSET'] || 'webmachine'
+gemset = "@#{gemset}" unless gemset.to_s == ''
+
+rvms = %W[  1.9.2 ].map {|v| "#{v}#{gemset}" }
+
+guard 'rspec', :cli => "--color --profile", :growl => true, :rvm => rvms do
+  watch(%r{^lib/webmachine/locale/.+$}) { "spec" }
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$}){ |m| "spec/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb') { "spec" }
+end

data/pkg/webmachine-0.1.0/README.md

@@ -0,0 +1,90 @@
+# webmachine for Ruby [![travis](https://secure.travis-ci.org/seancribbs/webmachine-ruby.png)](http://travis-ci.org/seancribbs/webmachine-ruby)
+
+webmachine-ruby is a port of
+[Webmachine](https://github.com/basho/webmachine), which is written in
+Erlang.  The goal of both projects is to expose interesting parts of
+the HTTP protocol to your application in a declarative way.  This
+means that you are less concerned with handling requests directly and
+more with describing the behavior of the resources that make up your
+application. Webmachine is not a web framework _per se_, but more of a
+toolkit for building HTTP-friendly applications. For example, it does
+not provide a templating engine or a persistence layer; those choices
+are up to you.
+
+**NOTE**: _Webmachine is NOT compatible with Rack._ This is
+intentional! Rack obscures HTTP in a way that makes it hard for
+Webmachine to do its job properly, and encourages people to add
+middleware that might break Webmachine's behavior. Rack is also built
+on the tradition of CGI, which is nice for backwards compatibility but
+also an antiquated paradigm and should be scuttled (IMHO). _Rack may
+be supported in the future, but only as a shim to support other web
+application servers._
+
+## Getting Started
+
+Webmachine is very young, but it's still easy to construct an
+application for it!
+
+```ruby
+    require 'webmachine'
+    # Require any of the files that contain your resources here
+    require 'my_resource' 
+     
+    # Point all URIs at the MyResource class
+    Webmachine::Dispatcher.add_route(['*'], MyResource)
+     
+    # Start the server, binds to port 3000 using WEBrick
+    Webmachine.run 
+```
+
+Your resource will look something like this:
+
+```ruby
+    class MyResource < Webmachine::Resource
+      def to_html
+        "<html><body>Hello, world!</body></html>"
+      end
+    end
+```
+
+Run the first file and your application is up. That's all there is to
+it! If you want to customize your resource more, look at the available
+callbacks in lib/webmachine/resource/callbacks.rb. For example, you
+might want to enable "gzip" compression on your resource, for which
+you can simply add an `encodings_provided` callback method:
+
+```ruby
+    class MyResource < Webmachine::Resource
+      def encodings_provided
+        {"gzip" => :encode_gzip, "identity" => :encode_identity}
+      end
+      
+      def to_html
+        "<html><body>Hello, world!</body></html>"
+      end
+    end
+```
+
+There are many other HTTP features exposed to your resource through
+callbacks. Give them a try!
+
+## Features
+
+* Handles the hard parts of content negotiation, conditional
+  requests, and response codes for you.
+* Most callbacks can interrupt the decision flow by returning an
+  integer response code. You generally only want to do this when new
+  information comes to light, requiring a modification of the response.
+* Currently supports WEBrick. Other host servers are planned.
+* Streaming/chunked response bodies are permitted as Enumerables or Procs.
+* Unlike the Erlang original, it does real Language negotiation.
+
+## Problems/TODOs
+
+* Support streamed responses as Fibers.
+* Configuration, command-line tools, and general polish.
+* An effort has been made to make the code feel as Ruby-ish as
+  possible, but there is still work to do.
+* Tracing is exposed as an Array of decisions visited on the response
+  object. You should be able to turn this off and on, and visualize
+  the decisions on the sequence diagram.

data/pkg/webmachine-0.1.0/Rakefile

@@ -0,0 +1,31 @@
+require 'rubygems'
+require 'rubygems/package_task'
+
+def gemspec
+  $webmachine_gemspec ||= Gem::Specification.load("webmachine.gemspec")
+end
+
+Gem::PackageTask.new(gemspec) do |pkg|
+  pkg.need_zip = false
+  pkg.need_tar = false
+end
+
+task :gem => :gemspec
+
+desc %{Validate the gemspec file.}
+task :gemspec do
+  gemspec.validate
+end
+
+desc %{Release the gem to RubyGems.org}
+task :release => :gem do
+  system "gem push pkg/#{gemspec.name}-#{gemspec.version}.gem"
+end
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+
+desc "Run specs"
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec