sinatra 0.1.0

data/lib/sinatra/context.rb

@@ -0,0 +1,88 @@
+require File.dirname(__FILE__) + '/context/renderer'
+
+module Sinatra
+
+  class EventContext
+  
+    cattr_accessor :logger
+    attr_reader :request
+
+    include Sinatra::Renderer
+  
+    def initialize(request) #:nodoc:
+      @request = request
+      @headers = {}
+    end
+  
+    # Sets or returns the status
+    def status(value = nil)
+      @status = value if value
+      @status || 200
+    end
+  
+    # Sets or returns the body
+    # *Usage*
+    #   body 'test'
+    # or
+    #   body do
+    #     'test'
+    #   end
+    # both are the same
+    #
+    def body(value = nil, &block)
+      @body = value if value
+      @body = block.call if block
+      @body
+    end
+    
+    # Renders an exception to +body+ and sets status to 500
+    def error(value = nil)
+      if value
+        status 500
+        @error = value
+        erb :error, :views_directory => SINATRA_ROOT + '/files/'
+      end
+      @error
+    end
+      
+    # Sets or returns response headers
+    #
+    # *Usage*
+    #   header 'Content-Type' => 'text/html'
+    #   header 'Foo' => 'Bar'
+    # or
+    #   headers 'Content-Type' => 'text/html',
+    #           'Foo' => 'Bar'
+    # 
+    # Whatever blows your hair back
+    def headers(value = nil)
+      @headers.merge!(value) if value
+      @headers
+    end
+    alias :header :headers
+  
+    # Returns a Hash of session data.  Keys are symbolized
+    def session
+      request.env['rack.session']
+    end
+
+    # Returns a Hash of params.  Keys are symbolized
+    def params
+      @params ||= @request.params.symbolize_keys
+    end
+    
+    # Redirect to a url
+    def redirect(path)
+      logger.info "Redirecting to: #{path}"
+      status 302
+      header 'Location' => path
+    end
+  
+    def log_event #:nodoc:
+      logger.info "#{request.request_method} #{request.path_info} | Status: #{status} | Params: #{params.inspect}"
+      logger.exception(error) if error
+    end
+  
+  end
+
+end

data/lib/sinatra/context/renderer.rb

@@ -0,0 +1,75 @@
+Layouts = Hash.new # :nodoc:
+
+module Sinatra
+
+  # The magic or rendering happens here.  This is included in Sinatra::EventContext on load.
+  # 
+  # These methods are the foundation for Sinatra::Erb and Sinatra::Haml and allow you to quickly
+  # create custom wrappers for your favorite rendering engines outside of erb and haml.
+
+  module Renderer
+    
+    DEFAULT_OPTIONS = {
+      :views_directory => 'views',
+      :layout => :layout
+    }
+                
+
+    # Renders templates from a string or file and handles their layouts:
+    #
+    # Example:
+    #   module MyRenderer
+    #     def my(template, options, &layout)
+    #       render(template, :my, options, &layout)
+    #     end
+    #     
+    #     def render_my(template)
+    #       template.capitalize  # It capitalizes templates!!!!!  WOW!
+    #     end
+    #   end
+    #   Sinatra::EventContext.send :include, MyRenderer
+    # 
+    #   get '/' do
+    #      my "something"
+    #   end
+    # 
+    #   get_it '/' # => 'Something'
+    # 
+    # The second method is named render_extname.  render will call this dynamicly
+    # 
+    # paramaters:
+    # * +template+  If String, renders the string.  If Symbol, reads from file with the basename of the Symbol; uses +renderer+ for extension.
+    # * +renderer+  A symbol defining the render_ method to call and the extension append to +template+ when looking in the +views_directory+
+    # * +options+   An optional Hash of options (see next section)
+    # 
+    # options:
+    # * +:views_directory+ Allows you to override the default 'views' directory an look for the template in another
+    # * +:layout+          Which layout to use (see Sinatra::Dsl).  false to force a render with no layout.  Defaults to :default layout
+    #
+    def render(template, renderer, options = {})
+      options = DEFAULT_OPTIONS.merge(options)
+      
+      layout = block_given? ? yield : Layouts[options[:layout]]
+      
+      result_method = 'render_%s' % renderer
+      
+      if layout
+        send(result_method, layout) { send(result_method, determine_template(template, renderer, options)) }
+      else
+        send(result_method, determine_template(template, renderer, options))
+      end
+    end
+    
+    protected
+    
+      def determine_template(template, ext, options)
+        if template.is_a?(Symbol)
+          File.read("%s/%s.%s" % [options[:views_directory], template, ext])
+        else
+          template
+        end
+      end
+      
+  end
+  
+end

data/lib/sinatra/core_ext/array.rb

@@ -0,0 +1,5 @@
+class Array
+  def to_hash
+    self.inject({}) { |h, (k, v)|  h[k] = v; h }
+  end
+end

data/lib/sinatra/core_ext/class.rb

@@ -0,0 +1,49 @@
+# Extends the class object with class and instance accessors for class attributes,
+# just like the native attr* accessors for instance attributes.
+class Class # :nodoc:
+  def cattr_reader(*syms)
+    syms.flatten.each do |sym|
+      next if sym.is_a?(Hash)
+      class_eval(<<-EOS, __FILE__, __LINE__)
+        unless defined? @@#{sym}
+          @@#{sym} = nil
+        end
+
+        def self.#{sym}
+          @@#{sym}
+        end
+
+        def #{sym}
+          @@#{sym}
+        end
+      EOS
+    end
+  end
+
+  def cattr_writer(*syms)
+    options = syms.last.is_a?(Hash) ? syms.pop : {}
+    syms.flatten.each do |sym|
+      class_eval(<<-EOS, __FILE__, __LINE__)
+        unless defined? @@#{sym}
+          @@#{sym} = nil
+        end
+
+        def self.#{sym}=(obj)
+          @@#{sym} = obj
+        end
+
+        #{"
+        def #{sym}=(obj)
+          @@#{sym} = obj
+        end
+        " unless options[:instance_writer] == false }
+      EOS
+    end
+  end
+
+  def cattr_accessor(*syms)
+    cattr_reader(*syms)
+    cattr_writer(*syms)
+  end
+  
+end

data/lib/sinatra/core_ext/hash.rb

@@ -0,0 +1,7 @@
+class Hash
+
+  def symbolize_keys
+    self.inject({}) { |h,(k,v)| h[k.to_sym] = v; h }
+  end
+
+end

data/lib/sinatra/core_ext/kernel.rb

@@ -0,0 +1,16 @@
+module Kernel
+  # (Taken from ActiveSupport)
+  # Sets $VERBOSE to nil for the duration of the block and back to its original value afterwards.
+  #
+  #   silence_warnings do
+  #     value = noisy_call # no warning voiced
+  #   end
+  #
+  #   noisy_call # warning voiced
+  def silence_warnings
+    old_verbose, $VERBOSE = $VERBOSE, nil
+    yield
+  ensure
+    $VERBOSE = old_verbose
+  end
+end

data/lib/sinatra/core_ext/metaid.rb

@@ -0,0 +1,18 @@
+# Compliments to why for this:
+# http://whytheluckystiff.net/articles/seeingMetaclassesClearly.html
+
+class Object
+   # The hidden singleton lurks behind everyone
+   def metaclass; class << self; self; end; end
+   def meta_eval &blk; metaclass.instance_eval &blk; end
+
+   # Adds methods to a metaclass
+   def meta_def name, &blk
+     meta_eval { define_method name, &blk }
+   end
+
+   # Defines an instance method within a class
+   def class_def name, &blk
+     class_eval { define_method name, &blk }
+   end
+end

data/lib/sinatra/core_ext/module.rb

@@ -0,0 +1,11 @@
+class Module
+  def attr_with_default(sym, default)
+    define_method "#{sym}=" do |obj|
+      instance_variable_set("@#{sym}", obj)
+    end
+
+    define_method sym do 
+      instance_variable_get("@#{sym}") || default
+    end
+  end
+end

data/lib/sinatra/core_ext/symbol.rb

@@ -0,0 +1,5 @@
+class Symbol
+  def to_proc 
+    Proc.new { |*args| args.shift.__send__(self, *args) }
+  end
+end

data/lib/sinatra/dispatcher.rb

@@ -0,0 +1,27 @@
+module Sinatra
+    
+  class Dispatcher
+
+    cattr_accessor :logger
+        
+    def default_headers
+      { 'Content-Type' => 'text/html' }
+    end
+
+    def call(env)
+      Loader.reload! if Options.environment == :development
+    
+      @request = Rack::Request.new(env)
+    
+      event = EventManager.determine_event(
+        @request.request_method.downcase.intern, 
+        @request.path_info
+      )
+    
+      result = event.attend(@request)
+      [result.status, default_headers.merge(result.headers), result.body]
+    end
+    
+  end
+  
+end

data/lib/sinatra/dsl.rb

@@ -0,0 +1,163 @@
+
+module Sinatra
+
+  module Dsl
+
+    # Define an Event that responds to a +path+ on GET method
+    # 
+    # The +path+ can be a template (i.e. '/:foo/bar/:baz').  When recognized, it will add <tt>:foo</tt> and <tt>:baz</tt> to +params+ with their values.
+    #
+    # Example:
+    #   # Going RESTful
+    #
+    #   get '/' do
+    #     .. show stuff ..
+    #   end
+    #   
+    #   post '/' do
+    #     .. add stuff ..
+    #     redirect '/'
+    #   end
+    #   
+    #   put '/:id' do
+    #     .. update params[:id] ..
+    #     redirect '/'
+    #   end
+    #   
+    #   delete '/:id' do
+    #     .. delete params[:id] ..
+    #     redirect '/'
+    #   end
+    #
+    # BIG NOTE: PUT and DELETE are trigged when POSTing to their paths with a <tt>_method</tt> param whose value is PUT or DELETE
+    #
+    def get(path, &block)
+      Sinatra::Event.new(:get, path, &block)
+    end
+
+    # Same as get but responds to POST
+    def post(path, &block)
+      Sinatra::Event.new(:post, path, &block)
+    end
+
+    # Same as get but responds to PUT
+    #
+    # BIG NOTE: PUT and DELETE are trigged when POSTing to their paths with a <tt>_method</tt> param whose value is PUT or DELETE
+    def put(path, &block)
+      Sinatra::Event.new(:put, path, &block)
+    end
+
+    # Same as get but responds to DELETE
+    #
+    # BIG NOTE: PUT and DELETE are trigged when POSTing to their paths with a <tt>_method</tt> param whose value is PUT or DELETE
+    def delete(path, &block)
+      Sinatra::Event.new(:delete, path, &block)
+    end
+
+    # Run given block after each Event's execution
+    # Example:
+    #   after_attend do
+    #     logger.debug "After event attend!"
+    #   end
+    def after_attend(filter_name = nil, &block)
+      Sinatra::Event.after_attend(filter_name, &block)
+    end
+  
+    # Add methods to each event for use during execution
+    #
+    # Example:
+    #   helpers do
+    #     def foo
+    #       'foo!'
+    #     end
+    #   end
+    #   
+    #   get '/bar' do
+    #     foo
+    #   end
+    #   
+    #   get_it '/bar' # => 'foo!'
+    #
+    def helpers(&block)
+      Sinatra::EventContext.class_eval(&block)
+    end
+
+    # Maps a path to a physical directory containing static files
+    #
+    # Example:
+    #   static '/p', 'public'
+    #
+    def static(path, root)
+      Sinatra::StaticEvent.new(path, root)
+    end
+    
+    # Execute block if in development mode (Used for configuration)
+    def development
+      yield if Sinatra::Options.environment == :development
+    end
+  
+    # Execute block if in production mode (Used for configuration)
+    def production
+      yield if Sinatra::Options.environment == :production
+    end
+  
+    # Execute block if in test mode (Used for configuration)
+    def test
+      yield if Sinatra::Options.environment == :test
+    end
+  
+    # Define named layouts (default name is <tt>:layout</tt>)
+    # 
+    # Examples:
+    #   # Default layout in Erb
+    #   layout do
+    #     '-- <%= yield %> --'
+    #   end
+    #   
+    #   # Named layout in Haml
+    #   layout :for_haml do
+    #     '== XXXX #{yield} XXXX'
+    #   end
+    #   
+    #   # Loads layout named <tt>:"foo.erb"</tt> from file (default behaviour if block is omitted)
+    #   layout 'foo.erb' # looks for foo.erb.  This is odd an is being re-thought
+    #   
+    #   def layout(name = :layout, options = {})
+    #     Layouts[name] = unless block_given?
+    #       File.read("%s/%s" % [options[:views_directory] || 'views', name])
+    #     else
+    #       yield
+    #     end
+    #   end
+    #
+    # Cool trick:
+    #   
+    #   # Send a one-time layout to renderer method
+    #   get '/cooltrick' do
+    #     erb 'wicked' do
+    #       'Cool <%= yield %> Trick'
+    #     end
+    #   end
+    #   
+    #   get_it '/cooltrick' # => 'Cool wicked Trick'
+    #
+    def layout(name = :layout, options = {})
+      Layouts[name] = unless block_given?
+        File.read("%s/%s" % [options[:views_directory] || 'views', name])
+      else
+        yield
+      end
+    end  
+  
+    # Turn sessions <tt>:on</tt> or <tt>:off</tt>
+    #  
+    # NOTE:  There is currently no way to turn it on or off per Event... patches anyone?)
+    def sessions(on_off)
+      Sinatra::Session::Cookie.use = on_off
+    end
+
+  end
+
+end
+
+include Sinatra::Dsl