mwmitchell-snap 0.5.0

data/LICENSE

@@ -0,0 +1,22 @@
+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
+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/README

@@ -0,0 +1,132 @@
+=Snap
+
+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
+
+# Nested GET/POST handler for /contact
+	class GetPost
+	  extend Snap::App
+	  map do
+	    map :contact do
+	      get{}
+	      post{}
+	    end
+	  end
+	end
+
+==Logic Flow
+
+================================================================
+
+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.
+ 
+<pre>
+<code>
+run SeriousApp::Root.new
+</code>
+</pre>

data/examples/demo.rb

@@ -0,0 +1,84 @@
+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

@@ -0,0 +1,56 @@
+#
+#
+#
+
+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

@@ -0,0 +1,64 @@
+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

@@ -0,0 +1,180 @@
+###
+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

@@ -0,0 +1,43 @@
+#
+#
+#
+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

@@ -0,0 +1,99 @@
+=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/context.rb

@@ -0,0 +1,9 @@
+#
+#
+#
+module Snap::Context
+  autoload :Base, 'snap/context/base'
+  autoload :Events, 'snap/context/events'
+  autoload :Matcher, 'snap/context/matcher'
+  autoload :Actions, 'snap/context/actions'
+end

data/lib/snap/demo.rb

@@ -0,0 +1,169 @@
+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

data/lib/snap/request.rb

@@ -0,0 +1,11 @@
+class Snap::Request < Rack::Request
+  
+  def m
+    request_method.to_s.downcase.to_sym
+  end
+  
+  def path_info_slices
+    ['/'] + path_info.to_s.gsub(/\/+/, '/').sub(/^\/|\/$/, '').split('/')
+  end
+  
+end

data/lib/snap.rb

@@ -0,0 +1,27 @@
+$:.delete_if {|v|v=~/TextMate/}
+
+$:.unshift File.dirname(__FILE__) unless
+  $:.include?(File.dirname(__FILE__)) or $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+require 'rubygems'
+require 'rack'
+
+class Proc
+  
+  #
+  # grab the file and line number from to_s
+  #
+  def source
+    @source ||= self.to_s.scan(/@(.*:\d+)\>/)
+  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

metadata

@@ -0,0 +1,75 @@
+--- !ruby/object:Gem::Specification 
+name: mwmitchell-snap
+version: !ruby/object:Gem::Version 
+  version: 0.5.0
+platform: ruby
+authors: 
+- Matt Mitchell
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-06-21 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rack
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        version: 0.3.0
+    version: 
+description: Snap is a Ruby, DSL based framework for creating RESTful web applications.
+email: goodieboy@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+- LICENSE
+files: 
+- README
+- LICENSE
+- CHANGES
+- examples/demo.rb
+- lib/snap.rb
+- lib/snap/app.rb
+- lib/snap/context.rb
+- lib/snap/demo.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
+has_rdoc: true
+homepage: http://github.com/mwmitchell/snap
+post_install_message: 
+rdoc_options: 
+- --main
+- README
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+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.
+test_files: []
+