mwmitchell-snap 0.5.0 → 0.6.0

data/LICENSE

@@ -1,5 +1,5 @@
 Copyright (c) 2008 Matt Mitchell - goodieboy@gmail.com
-
+ 
 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
@@ -8,10 +8,10 @@ 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
@@ -19,4 +19,4 @@ 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.
+OTHER DEALINGS IN THE SOFTWARE.

data/README

@@ -1,132 +1,59 @@
-=Snap
+= Snap - REST made easy
 
-Snap is a ruby framework for creating `RESTful` web applications. Using Rack: http://rack.rubyforge.org - "Rack: a Ruby Webserver Interface", it's designed to be flexible, fast and easy to understand.
- 
-==Examples
- 
-# Simple GET/POST handler for /
-	class GetPost
-	  extend Snap::App
-	  map do
-	    get{}
-	    post{}
-	  end
-	end
+== Overview
+Snap is a small web framework for creating RESTful web applications. The heart of Snap is the controller layer; a contextual, block based DSL featuring RESTful action hooks, an event filter system and url param mapping.
 
-# Nested GET/POST handler for /contact
-	class GetPost
-	  extend Snap::App
-	  map do
-	    map :contact do
-	      get{}
-	      post{}
-	    end
-	  end
-	end
+The start of any Snap application is a root Context. Contexts are sub-slices of a url and help keep routes DRY. The Context is responsible for defining the base URL path for it's actions, filters and child Contexts. One Context is equal to a set of URL path fragments. For example, a context could be /admin/transactions. Within that Context, there can be multiple actions, filters and sub-contexts.
 
-==Logic Flow
+The request and before/after handlers are able to negotiate different formats of content using the :format method within an action block.
 
-================================================================
+Snap is very similar to Sinatra in that each action is a simple block. Snap is a little more structured and flexible than Sinatra. This can be a disadvantage or an advantage depending on the type of app you're trying to build.
 
-Snap is a Ruby, DSL based framework for creating RESTful web applications. It adheres to the Ruby Rack specification.
- 
-Snap treats every fragment in a URL as a "context". Each context can be mapped to a block or another Snap enabled module. For example, a URL of:
- 
-<pre>/users/1/images/1</pre>
- 
-could translate to a context block tree of:
- 
-<pre>
-<code>
-map 'users' do
-  map :digit do
-    get{"The value of this user is #{value}"}
-    map 'images' do
-      map :digit do
-        get{"The ID of this image is #{value}"}
-      end
-    end
-  end
-end
-</code>
-</pre>
- 
-Because each block maps to a single url fragment, "routing" is not needed. The value of a context's url fragment can be accessed by its :value attribute. You can also name the fragment and propagate to the request params like:
- 
-<pre>
-<code>
-map :user_id=>/\d+/ do
-  puts params[:user_id]
-end
-</code>
-</pre>
- 
-The :user_id param will then be available as a global request param to other contexts and "actions".
- 
-The fragment value passed to :map can be a string, a regular expression or a symbol that matches one of the built-in rules; :digit, :word, etc.
- 
-Standard HTTP methods (GET, POST, PUT, etc.) are used as the "actions". Each of the actions methods can accept a "rule" hash. The keys map to the REQUEST values (but down-cased and symbolized). So you could execute an action only if it matched the IP, or SERVER_NAME. The value of the rule can be a Regular Expression or a string.
- 
-Here is an example:
- 
-<pre>
-<code>
-require 'snap'
- 
-module SeriousApp
-  
-  class Contact # A delegate/sub-app
-    
-    extend Snap::App
-    
-    build do
-      before :post do
-        # a before :post block. Default is :all.
-      end
-      
-      get{'GET request'}
-      post{'POST request'}
-      
-      # request for /contact/:word
-      map :word do
-        get{"GET request for /contact/#{value}"}
-      end
-    end
-  end
-  
-  class Root
-    
-    extend Snap::App
-    
-    build do
-      get{'A simple GET to /'}
-      post{'A POST to /'}
-      
-      # /about/
-      map 'about' do
-        get{'GET request for /about'}
-      end
-      
-      # /notes
-      map 'notes' do
-        get(:server_name=>/^myspecialdomain\.com$/) do
-          'GET request for /notes, but only allowing a SERVER_NAME of "myspecialdomain.com"'}
-        end
-      end
-      
-      # forwarding /contact to the Contact class
-      map 'contact' { use Contact }
-    end
-    
-  end
-end
-</code>
-</pre>
- 
-You then instantiate the Root class, and pass it to Rack's "run" method.
+* Thanks to Merb and Sinatra for the little bits of code here and there
+
+== Example
+Here is a simple example:
+
+module SimpleApp; end
  
-<pre>
-<code>
-run SeriousApp::Root.new
-</code>
-</pre>
+class SimpleApp::Root
+
+	include Snap::App
+
+	map do
+
+		after do
+			nav = <<-EOF
+				<ul>
+					<li><a href="/">home</a></li>
+					<li><a href="/about">about</a></li>
+					<li><a href="/about/ruby">about ruby</a></li>
+					<li><a href="/markaby">markaby example</a></li>
+				</ul>
+			EOF
+			response.body = "<h1>Snap!</h1><hr/>#{nav}#{response.body}<hr/>"
+		end
+
+		get {'The root path using GET'}
+
+		get :markaby=>'markaby' do
+			markaby.div do
+				h3 "Render your HTML with Markaby?"
+				ul do
+					li "markaby is cool"
+					li "It's fun to put view logic in your controllers :)"
+					li "testing..."
+				end
+			end
+		end
+
+		map 'about' do
+			get {"Snap is an experimental framework?!"}
+			get 'ruby' do
+				'Ruby -> http://www.ruby-lang.org'
+			end
+		end
+		
+	end
+
+end

data/bin/snap

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+require 'rubygems'
+require 'rake'
+Rake.application.run

data/lib/core_ext.rb

@@ -0,0 +1,108 @@
+class Symbol
+  def to_proc
+    proc { |obj, *args| obj.send(self, *args) }
+  end
+end
+
+class Proc
+  
+  def source
+    self.to_s.scan(/@(.*)>/)
+  end
+  
+end
+
+class String
+  
+  # Converts +self+ to an escaped URI parameter value
+  #   'Foo Bar'.to_param # => 'Foo%20Bar'
+  def to_param
+    URI.escape(self)
+  end
+  
+  # Converts +self+ from an escaped URI parameter value
+  #   'Foo%20Bar'.from_param # => 'Foo Bar'
+  def from_param
+    URI.unescape(self)
+  end
+  
+  #
+  # :trim and :trim!
+  # Similar to PHP's trim function
+  # Aceepts multiple arguments for characters to trim
+  # from the beginning of the string and the end
+  #
+	%W(trim trim!).each do |m|
+	  define_method m do |*args|
+	    raise 'Characters argument missing' unless (chars=args.join(' '))
+	    p = [/^[#{Regexp.escape(chars)}]+|[#{Regexp.escape(chars)}]+$/, '']
+	    m[-1..-1] == '!' ? self.gsub!(*p) : self.gsub(*p)
+	  end
+	end
+  
+  #
+  # Removes duplicate instances of characters
+  #
+	%W(dedup dedup!).each do |m|
+	  define_method m do |*args|
+	    raise 'Character argument missing' if args.nil?
+	    value=self
+	    args.each do |char|
+	      p = [/#{Regexp.escape(char)}+/, char]
+	      m[-1..-1] == '!' ? self.gsub!(*p) : (value = value.gsub(*p))
+	    end
+	    value
+	  end
+	end
+
+	#
+	# removes starting and ending instances of the characters argument (calls :trim)
+	# replaces sets of duplicated characters with a single character (calls :dedup)
+	# 
+	# puts 'testtktu'.cleanup('t', 'u') == 'estk'
+	# 
+	%W(cleanup cleanup!).each do |m|
+	  define_method m do |*args|
+	    m[-1..-1] == '!' ? (trim!(*args) && dedup!(*args)) : (trim(*args).dedup(*args))
+	  end
+	end
+
+end
+
+class Hash
+  
+  def deep_merge(hash)
+    target = dup
+    hash.keys.each do |key|
+      if hash[key].is_a? Hash and self[key].is_a? Hash
+        target[key] = target[key].deep_merge(hash[key])
+        next
+      end
+      target[key] = hash[key]
+    end
+    target
+  end
+  
+  def deep_merge!(second)
+    second.each_pair do |k,v|
+      if self[k].is_a?(Hash) and second[k].is_a?(Hash)
+        self[k].deep_merge!(second[k])
+      else
+        self[k] = second[k]
+      end
+    end
+  end
+  
+  def to_params
+    map { |k,v| "#{k}=#{URI.escape(v)}" }.join('&')
+  end
+
+  def symbolize_keys
+    self.inject({}) { |h,(k,v)| h[k.to_sym] = v; h }
+  end
+
+  def pass(*keys)
+    reject { |k,v| !keys.include?(k) }
+  end
+
+end

data/lib/snap.rb

@@ -1,27 +1,32 @@
-$:.delete_if {|v|v=~/TextMate/}
-
-$:.unshift File.dirname(__FILE__) unless
-  $:.include?(File.dirname(__FILE__)) or $:.include?(File.expand_path(File.dirname(__FILE__)))
+lambda do |p|
+  $:.unshift p unless
+    $:.include?(p) or $:.include?(File.expand_path(p))
+end.call(File.dirname(__FILE__))
 
 require 'rubygems'
 require 'rack'
+require 'core_ext'
 
-class Proc
+module Snap
   
-  #
-  # grab the file and line number from to_s
-  #
-  def source
-    @source ||= self.to_s.scan(/@(.*:\d+)\>/)
+  module Version
+    MAJOR = '0'
+    MINOR = '4'
+    REVISION = '1'
+    def self.combined
+      [MAJOR, MINOR, REVISION].join('.')
+    end
   end
   
 end
 
-module Snap
-  autoload :App, 'snap/app'
-  autoload :Context, 'snap/context'
-  autoload :Request, 'snap/request'
-  autoload :Demo, 'snap/demo'
-  autoload :Config, 'snap/config'
-  autoload :HashBlock, 'snap/hash_block'
-end
+%W(
+  config
+  context
+  initializer
+  response_helpers
+  request
+  zone
+  view_helper
+  app
+).each{|p|require "snap/#{p}"}

data/lib/snap/context.rb

@@ -1,9 +1,23 @@
 #
-#
+# The "Context" is essentially the current request
 #
 module Snap::Context
-  autoload :Base, 'snap/context/base'
-  autoload :Events, 'snap/context/events'
-  autoload :Matcher, 'snap/context/matcher'
-  autoload :Actions, 'snap/context/actions'
+  
+  # these will be accessable thru Snap::Context
+  M=%W(request response config)
+  
+  # class instance attributes (ex. Snap::Context.config etc.)
+  class << self
+    M.each{|meth| attr_accessor meth}
+  end
+  
+  # This makes the above methods available to the classes that "include Snap::Context"
+  M.each do |meth|
+    class_eval <<-EOF
+      def #{meth}(*args)
+        Snap::Context.send(:#{meth}, *args)
+      end
+    EOF
+  end
+  
 end

data/lib/snap/request.rb

@@ -1,11 +1,50 @@
 class Snap::Request < Rack::Request
   
-  def m
-    request_method.to_s.downcase.to_sym
+  def initialize(env)
+    super(env)
+    pi=env['PATH_INFO'].to_s.split('.')
+    @path_info=pi.first.cleanup('/')
+    @format=pi.size==2 ? pi.last.to_sym : default_format
+    @request_method=env['REQUEST_METHOD'].downcase.to_sym
+    if post_tunnel_method_hack?
+      @request_method = params['_method'].downcase.to_sym
+    end
   end
   
-  def path_info_slices
-    ['/'] + path_info.to_s.gsub(/\/+/, '/').sub(/^\/|\/$/, '').split('/')
+  def default_format; :html end
+  
+  def format
+    @format
+  end
+  
+  def path_info
+    @path_info
   end
   
+  # Set of request method names allowed via the _method parameter hack. By default,
+  # all request methods defined in RFC2616 are included, with the exception of
+  # TRACE and CONNECT.
+  POST_TUNNEL_METHODS_ALLOWED = [:put, :delete, :options, :head]
+  
+  # Return the HTTP request method with support for method tunneling using the POST
+  # _method parameter hack.  If the real request method is POST and a _method param is
+  # given and the value is one defined in +POST_TUNNEL_METHODS_ALLOWED+, return the value
+  # of the _method param instead.
+  def request_method
+    @request_method
+  end
+  
+  private
+
+    # Return truthfully if and only if the following conditions are met: 1.) the
+    # *actual* request method is POST, 2.) the request content-type is one of
+    # 'application/x-www-form-urlencoded' or 'multipart/form-data', 3.) there is a 
+    # "_method" parameter in the POST body (not in the query string), and 4.) the 
+    # method parameter is one of the verbs listed in the POST_TUNNEL_METHODS_ALLOWED
+    # list.
+    def post_tunnel_method_hack?
+      @request_method == :post &&
+        POST_TUNNEL_METHODS_ALLOWED.include?(self.POST.fetch('_method', '').downcase.to_sym)
+    end
+  
 end

data/lib/snap/response_helpers.rb

@@ -0,0 +1,89 @@
+module Snap::ResponseHelpers
+  
+  class FormatMapper
+    
+    def initialize
+      @formats={}
+    end
+    
+    def method_missing(m,&block)
+      # check with mime-types here...
+      @formats[m]=block
+    end
+    
+    def resolve(format)
+      @formats[format]
+    end
+    
+  end
+  
+  def format_mapper
+    @format_mapper||=FormatMapper.new
+  end
+  
+  def format
+    format_mapper
+  end
+  
+  def redirect(path, *args)
+    response.status=302
+    headers 'Location' => path
+    throw :halt, *args
+  end
+  
+  def stop(*args)
+    throw :halt, args
+  end
+  
+  def response
+    @response
+  end
+  
+  def headers(header = nil)
+    response.headers.merge!(header) if header
+    response.headers
+  end
+  
+  alias :header :headers
+  
+  def render(template=nil, variables={}, options={})
+    options[:renderer]||=config.default_renderer
+    m = "render_#{options[:renderer]}"
+    config.view_paths.each do |p|
+      template = File.read(File.join(p, "#{template}.#{request.format}.erb")) rescue nil
+    end
+    render_erb([self], erb_helpers, template, variables)
+  end
+  
+  def erb_helpers
+    [Snap::ViewHelper::Erubis]
+  end
+  
+  def render_erb(variable_bindings, extensions, template, data={})
+    variable_bindings.each do |o|
+      o.instance_variables.each do |k|
+        data[k[1..-1]]=o.instance_variable_get(k)
+      end
+    end
+    context=Object.new
+    extensions.each do |e|
+      context.extend e
+    end
+    data.each do |k,v|
+      context.instance_variable_set("@#{k}", v)
+    end
+    require 'erubis_ext'
+    ::Erubis::BlockAwareEruby.new(nil, :trim=>false).process(template, context)
+  end
+  
+  def render_haml(content, options = {}, &b)
+    require 'haml'
+    ::Haml::Engine.new(content).render(options[:scope] || self, options[:locals] || {}, &b)
+  end
+  
+  def markaby
+    require 'markaby'
+    Markaby::Builder.new
+  end
+  
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: mwmitchell-snap
 version: !ruby/object:Gem::Version 
-  version: 0.5.0
+  version: 0.6.0
 platform: ruby
 authors: 
 - Matt Mitchell
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-06-21 00:00:00 -07:00
+date: 2008-08-06 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -19,9 +19,9 @@ dependencies:
     requirements: 
     - - "="
       - !ruby/object:Gem::Version 
-        version: 0.3.0
+        version: 0.4.0
     version: 
-description: Snap is a Ruby, DSL based framework for creating RESTful web applications.
+description: Snap - a minimalist framework for creating RESTful web applications
 email: goodieboy@gmail.com
 executables: []
 
@@ -33,17 +33,20 @@ extra_rdoc_files:
 files: 
 - README
 - LICENSE
-- CHANGES
-- examples/demo.rb
+- bin/snap
+- lib/core_ext.rb
 - lib/snap.rb
-- lib/snap/app.rb
+- lib/snap/action.rb
+- lib/snap/context/action_methods.rb
+- lib/snap/context/hooks.rb
 - lib/snap/context.rb
-- lib/snap/demo.rb
+- lib/snap/event.rb
+- lib/snap/loader.rb
+- lib/snap/negotiator.rb
+- lib/snap/rack_runner.rb
+- lib/snap/renderers.rb
 - lib/snap/request.rb
-- lib/snap/context/base.rb
-- lib/snap/context/actions.rb
-- lib/snap/context/events.rb
-- lib/snap/context/matcher.rb
+- lib/snap/response_helpers.rb
 has_rdoc: true
 homepage: http://github.com/mwmitchell/snap
 post_install_message: 
@@ -70,6 +73,6 @@ rubyforge_project:
 rubygems_version: 1.2.0
 signing_key: 
 specification_version: 2
-summary: Snap is a Ruby, DSL based framework for creating RESTful web applications.
+summary: Snap - a minimalist framework for creating RESTful web applications
 test_files: []
 

data/examples/demo.rb

@@ -1,84 +0,0 @@
-require File.join(File.dirname(__FILE__), '..', 'lib', 'snap')
-
-app=Snap::Demo::Controllers::Root.new
-
-rack_env=Rack::MockRequest.env_for('/admin/customers', {'REQUEST_METHOD'=>'GET', 'SERVER_PORT'=>'80'})
-puts app.call(rack_env)
-
-puts "
-...
-
-"
-
-
-rack_env=Rack::MockRequest.env_for('/admin/customers/henry', {'REQUEST_METHOD'=>'PUT', 'SERVER_PORT'=>'80'})
-puts app.call(rack_env)
-
-puts "
-...
-
-"
-
-
-
-rack_env=Rack::MockRequest.env_for('/', {'REQUEST_METHOD'=>'GET', 'SERVER_PORT'=>'80'})
-puts app.call(rack_env)
-
-puts "
-...
-
-"
-
-rack_env=Rack::MockRequest.env_for('/admin', {'REQUEST_METHOD'=>'GET', 'SERVER_PORT'=>'80'})
-puts app.call(rack_env)
-
-puts "
-...
-
-"
-
-rack_env=Rack::MockRequest.env_for('/admin/orders', {'REQUEST_METHOD'=>'POST', 'SERVER_PORT'=>'80'})
-puts app.call(rack_env)
-
-puts "
-...
-
-"
-
-
-rack_env=Rack::MockRequest.env_for('/admin/products', {'REQUEST_METHOD'=>'GET', 'SERVER_PORT'=>'80'})
-puts app.call(rack_env)
-
-puts "
-...
-
-"
-
-rack_env=Rack::MockRequest.env_for('/contact', {'REQUEST_METHOD'=>'GET', 'SERVER_PORT'=>'80'})
-puts app.call(rack_env)
-
-puts "
-...
-
-"
-
-rack_env=Rack::MockRequest.env_for('/contact/the-boss', {'REQUEST_METHOD'=>'GET', 'SERVER_PORT'=>'80'})
-puts app.call(rack_env)
-
-puts "
-...
-
-"
-
-rack_env=Rack::MockRequest.env_for('/admin/products/144/edit', {'REQUEST_METHOD'=>'GET', 'SERVER_PORT'=>'80'})
-puts app.call(rack_env)
-
-
-
-puts "
-...
-
-"
-
-rack_env=Rack::MockRequest.env_for('/admin/products/144', {'REQUEST_METHOD'=>'GET', 'SERVER_PORT'=>'80'})
-puts app.call(rack_env)

data/lib/snap/app.rb

@@ -1,56 +0,0 @@
-#
-#
-#
-
-require 'monitor'
-
-module Snap::App
-  
-  attr :root
-  
-  #
-  #
-  #
-  def map(options={}, &block)
-    @root=Snap::Context::Base.new('/', options, nil, &block)
-  end
-  
-  #
-  #
-  #
-  def self.extended(base)
-    
-    base.class_eval do
-      
-      #
-      # Provides sync functionality when using Threads and shared resources
-      #
-      include MonitorMixin
-      
-      attr_accessor :config
-      attr_accessor :request
-      attr_accessor :response
-      
-      #
-      #
-      #
-      def call(rack_env)
-        synchronize do
-          @request = Snap::Request.new(rack_env)
-          @response = Rack::Response.new
-          c=self.class.root.resolve(@request.path_info_slices, self)
-          result = c.execute if c
-          response.finish
-        end
-      end
-      
-    end
-  end
-  
-  class Base
-    
-    extend Snap::App
-    
-  end
-  
-end

data/lib/snap/context/actions.rb

@@ -1,64 +0,0 @@
-module Snap::Context::Actions
-  
-  #
-  #
-  #
-  def index(options={}, &block)
-    get(options, &block)
-  end
-  
-  #
-  #
-  #
-  def create(options={}, &block)
-    put(options, &block)
-  end
-  
-  #
-  #
-  #
-  def new(options={}, &block)
-    map(:new) do
-      get(options, &block)
-    end
-  end
-  
-  #
-  #
-  #
-  def show(pattern=:digit, options={}, &block)
-    map(pattern) do
-      get(options, &block)
-    end
-  end
-  
-  #
-  #
-  #
-  def update(pattern=:digit, options={}, &block)
-    map(pattern) do
-      put(options, &block)
-    end
-  end
-  
-  #
-  #
-  #
-  def delete(pattern=:digit, options={}, &block)
-    map(pattern) do
-      delete(options, &block)
-    end
-  end
-  
-  #
-  #
-  #
-  def edit(pattern={:id=>:digit}, options={}, &block)
-    map(pattern) do
-      map(:edit) do
-       get(options, &block)
-      end
-    end
-  end
-  
-end

data/lib/snap/context/base.rb

@@ -1,180 +0,0 @@
-###
-class Snap::Context::Base
-  
-  include Snap::Context::Events
-  include Snap::Context::Matcher
-  
-  attr :pattern
-  attr :options
-  attr_accessor :parent
-  attr :block
-  attr :app
-  attr :slices
-  attr :value
-  
-  def initialize(pattern, options={}, parent=nil, &block)
-    @pattern=pattern
-    @options=options
-    @parent=parent
-    @block=block
-  end
-  
-  [:get,:post,:put,:delete].each do |m|
-    class_eval <<-EOF
-      def #{m}(options={},&block)
-        # don't add the action if the block is the same as existing action block
-        unless actions.detect{|a|a[2].source==block.source}
-          actions << [:#{m},options,block]
-        end
-      end
-    EOF
-  end
-  
-  def app; @app end
-  def request; app.request end
-  def response; app.response end
-  def params; request.params end
-  def actions; @actions||=[] end
-  def children; @children||=[] end
-  
-  #
-  # builds the url path to this context
-  #
-  def path
-    @path ||= ((parent ? parent.path : '') + '/' + value).gsub(/\/+/, '/')
-  end
-  
-  #
-  # +use+ is the method that allows context to delegate
-  # to other contexts, alloing logic to be off-loaded
-  # to other classes. The klass argument
-  # must be the class name of an object that is
-  # using "extend Snap::App"
-  #
-  def use(klass,*args,&block)
-    usable_app=klass.new(*args,&block)
-    usable_app.class.root.parent=self
-    children<<usable_app
-  end
-  
-  #
-  # Define a new sub-context block
-  # pattern can be a string, a symbol or a hash
-  #
-  def map(pattern,options={},&block)
-    # don't add the context if the block is the same as existing action block
-    return if children.detect{|c|c.block.source == block.source}
-    children<<self.class.new(pattern,options,self,&block)
-  end
-  
-  #
-  #
-  #
-  def find_action(method, env={})
-    actions.detect{ |a| a[0] == method and options_match?(a[1], env)}
-  end
-  
-  #
-  #
-  #
-  def can?(*args)
-    ! find_action(*args).nil?
-  end
-  
-  #
-  #
-  #
-  def method_missing(m,*a,&block)
-    puts "METHOD MISSING #{m.inspect}"
-    puts "APP IS #{@app} (should not be a context::base)"
-    @app.send(m,*a,&block)
-  end
-  
-  #
-  #
-  #
-  def execute(method=request.m, env=request.env)
-    a=find_action(method,env)
-    result=nil
-    unless a.nil?
-      execute_before_and_after_blocks(method, env){result=instance_eval &a[2]}
-    end
-    result
-  end
-  
-  #
-  #
-  #
-  def resolve(slices, app)
-    @app=app
-    
-    method=app.request.m
-    env=app.request.env
-    
-    # 
-    # must clone the slices; in some cases we need to climb back up the context stack
-    # for example, if two contexts are defined with the same pattern
-    # but the first one doesn't define a matching action block,
-    # we need to be able to move back up to get the second one.
-    # if the slices aren't cloned, then the 2nd one
-    # would get a wrongly manipulated slices array - oh no!
-    # 
-    slices=slices.clone
-    
-    # try to match the @pattern with the given slices
-    # then extract the value
-    val = match?(@pattern,slices.first)
-    
-    return unless val    
-    
-    #
-    # now make sure that the options can match the env
-    #
-    return unless options_match?(@options, env)
-    
-    # if the returned value was a hash, merge it into the apps request.param hash
-    app.request.params.merge!(val) if val.is_a?(Hash)
-    
-    #
-    # shift off the first item, save it as the value
-    # of this context this is needed so that the
-    # next context can have the next
-    # value in the slices array
-    #
-    @value=slices.shift
-    
-    @slices=slices
-    
-    result = catch :halt do
-      instance_eval &@block
-    end
-    
-    #
-    # "and can?(method, env)" -> This seemed to allow falling back to an action that is a parent
-    #
-    return self if slices.empty?# and can?(method, env)
-    
-    matching_child=nil
-    children.each do |c|
-      if c.is_a?(self.class)
-        # standard Snap::Context::Base instance set by +map+
-        matching_child=c.resolve(slices, app)
-        # matching_child.parent=self if matching_child
-      else
-        # if this is an object set by the +use+ method
-        # c is not a Snap::Context::Base; it
-        # should be a class calling "extend Snap::App"
-        # (a sort of sub-application)
-        # so it needs a root slash for it's
-        # own "root" context...
-        # set the sub-app's request and response instances
-        c.request=request
-        c.response=response
-        matching_child=c.class.root.resolve(['/']+slices,c)
-      end
-      return matching_child if matching_child
-    end
-    nil
-  end
-  
-end

data/lib/snap/context/events.rb

@@ -1,43 +0,0 @@
-#
-#
-#
-module Snap::Context::Events
-  
-  include Snap::Context::Matcher
-  
-  def before_blocks; @before_blocks||={} end
-  def after_blocks; @after_blocks||={} end
-  
-  def before(action=:all, options={}, &block)
-    before_blocks[action]=[options,block]
-  end
-  
-  def after(action=:all, options={}, &block)
-    after_blocks[action]=[options,block]
-  end
-  
-  def execute_before_and_after_blocks(method, options, &block)
-    execute_before_blocks method, options
-    yield
-    execute_after_blocks method, options
-  end
-  
-  #
-  #
-  #
-  def execute_before_blocks(method, options={})
-    parent.execute_before_blocks(method, options) if parent
-    b=(@before_blocks[method] || @before_blocks[:all]) if @before_blocks
-    instance_eval(&b[1]) if b and options_match?(b[0], options)
-  end
-  
-  #
-  #
-  #
-  def execute_after_blocks(method, options={})
-    b=(@after_blocks[method] || @after_blocks[:all]) if @after_blocks
-    instance_eval(&b[1]) if b and options_match?(b[0], options)
-    parent.execute_after_blocks(method, options) if parent
-  end
-  
-end

data/lib/snap/context/matcher.rb

@@ -1,99 +0,0 @@
-=begin
-
-# TEST
-
-include Snap::Context::Matcher
-
-puts true == options_match?({}, {:server_name=>'localhost'})
-
-puts true ==options_match?({:server_name=>'localhost'}, {:server_name=>'localhost'})
-
-puts true == options_match?({:server_name=>/local/}, {:server_name=>'localhost'})
-
-puts false == options_match?({:server_name=>/k/}, {:server_name=>'localhost'})
-
-puts false == options_match?({:asdasd=>'x', :localhost=>'localhost'}, {:server_name=>'localhost'})
-
-puts true == options_match?({}, {:server_name=>'localhost', :port=>8080})
-
-puts false == options_match?({:port=>9}, {:port=>8080})
-
-=end
-
-#
-#
-#
-module Snap::Context::Matcher
-
-  PATTERNS={
-    :digit=>/^\d+$/,
-    :word=>/^\w+$/
-  }
-
-  #
-  # Checks the pattern against the value
-  # The pattern can be a:
-  #   * string - uses == to compare
-  #   * regexp - uses =~ to compare
-  #   * symbol - first looks up value in PATTERNS; if found, uses the PATTERN value; if not, converts to string
-  #   * hash - assigns the value to the key within the params array if matches; the value can be any of the above
-  #
-  # ==Examples
-  #   match?('hello', 'hello') == true
-  #   match?(/h/, 'hello') == true
-  #   match?(:digit, 1) == true - does a successfull lookup in PATTERNS
-  #   match?(:admin, 'admin') == true - non-succesfull PATTERNS lookup, convert to string
-  #   match?(:id=>:digit, 1) == true - also sets params[:id]=1
-  #   match?(:name=>:word, 'sam') == true - sets params[:name]='sam'
-  #   match?(:topic=>/^authors$|^publishers$/, 'publishers') - true - sets params[:topic]='publishers'
-  #
-  def match?(pattern, value)
-    ok = simple_match?(pattern, value)
-    return ok if ok
-    # if hash, use the value as the pattern and set the request param[key] to the value argument
-    return ({pattern.keys.first => match?(pattern[pattern.keys.first], value)}) if pattern.is_a?(Hash)
-    # if symbol
-    if pattern.is_a?(Symbol)
-      # lookup the symbol in the PATTERNS hash
-      if PATTERNS[pattern] and new_value=match?(PATTERNS[pattern], value)
-        return new_value
-      end
-      # There was no match, convert to string
-      simple_match?(pattern.to_s, value)
-    end
-  end
-
-  #
-  # Non-nested comparisons using == or =~
-  #
-  def simple_match?(pattern, value)
-    # if regexp, regx comparison
-    return value if (pattern.is_a?(Regexp) and value.to_s =~ pattern)
-    # if string, simple comparison
-    return value if (pattern.is_a?(String) and value.to_s == pattern)
-  end
-  
-  #
-  #
-  #
-  def options_match?(compare_from, compare_to)
-    if compare_from.to_s.empty?
-      return true
-    end
-    n={}
-    compare_to.each_pair{ |k,v| n[k.to_s.downcase.gsub('-','_').gsub(' ', '').gsub('.', '_').to_sym]=v }
-    matches=true
-    compare_from.each_pair do |k,v|
-      unless n.has_key?(k)
-        matches=false
-        break
-      end
-      unless match?(v,n[k]) or match?(v.to_s,n[k])
-        matches=false
-        break
-      end
-    end
-    matches
-  end
-  
-end

data/lib/snap/demo.rb

@@ -1,169 +0,0 @@
-module Snap::Demo
- 
-  module Controllers
-    
-    module Admin
-      
-      class Customers
-        
-        extend Snap::App
-        
-        map do
-          
-          extend Snap::Context::Actions
-          
-          index do
-            'Admin::Customers INDEX /admin/customers -> ' + path
-          end
-          
-          update :customer_name=>/\w+/ do
-            app.response.write 'TESTING'
-            "Admin::Customers UPDATE /admin/customers/#{params[:customer_name]} -> " + path
-          end
-          
-        end
-        
-      end
-      
-      class Products
-        
-        extend Snap::App
-        
-        map do
-          
-          extend Snap::Context::Actions
-          
-          before do
-            puts "Admin::Products BEFORE"
-          end
-          
-          after do
-            puts "Admin::Products AFTER"
-          end
-          
-          get{'Admin::Products GET /admin/products -> ' + path}
-          
-          map :product_id=>:digit do
-            get do 
-              out = "Admin::Products GET /admin/products/#{params[:product_id]} -> #{path}"
-              out += "\nThe parent path is #{parent.path}"
-            end
-          end
-          
-          edit do
-            out = "Admin::Products EDIT /admin/products/#{params[:id]}/edit -> " + path
-            out += "\nThe parent path is #{parent.path}"
-          end
-          
-          index do
-            'Admin::Products INDEX /admin/products'
-          end
-          
-          new :server_name=>/example/ do
-            'Admin::Products NEW /admin/products'
-          end
-          
-        end
-      end
-      
-    end
-    
-    class Contact
-      
-      extend Snap::App
-      
-      map do
-        
-        before{puts "Contact BEFORE"}
-        after{puts "Contact AFTER"}
-        
-        get{'Contact GET /'}
-        
-        map 'the-boss' do
-          before do
-            puts 'Contact BEFORE /the-boss'
-          end
-          after do
-            puts 'Contact AFTER /the-boss'
-          end
-          get{'Contact GET /the-boss -> ' + path}
-        end
-        
-      end
-    end
-    
-    class Root
-      
-      extend Snap::App
-      
-      attr_accessor :count
-
-      map do
-        
-        before do
-          puts 'Root BEFORE /'
-        end
-        
-        after do
-          puts 'Root AFTER /'
-        end
-        
-        get{'GET /'}
-        post{'POST /'}
-        put{'PUT /'}
-        delete{'DELETE /'}
-        
-        map :contact do
-          before do
-            puts 'Root BEFORE /contact'
-          end
-          after do
-            puts 'Root AFTER /contact'
-          end
-          map 'the-boss' do
-            before :post do
-              puts 'Root BEFORE-POST /contact/the-boss'
-            end
-            after :post do
-              puts 'Root AFTER-POST /contact/the-boss'
-            end
-            post{'Root POST /contact'}
-          end
-          use Contact
-        end
-        
-        map :admin do
-          map(:products){use Admin::Products}
-          map(:customers){use Admin::Customers}
-          map :orders do
-            post{'Root POST /admin/orders'}
-          end
-        end
-        
-        #
-        #
-        #
-        map :admin do
-          before do
-            puts "Root BEFORE /admin"
-          end
-          after do
-            puts "Root AFTER /admin"
-          end
-          get{'Root GET /admin'}
-          map :orders, :server_port=>/^8/ do
-            get :server_port=>80 do
-              ':80 GET /admin/orders'
-            end
-            get :server_port=>81 do 
-              ':81 GET /admin/orders'
-            end
-          end
-        end
-      end
-     
-    end
-   
-  end
- 
-end