sinatra 0.1.7 → 0.2.0

data/lib/sinatra/dsl.rb

@@ -1,176 +0,0 @@
-
-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
-    # Usage:
-    #   before_attend do
-    #     logger.debug "After event attend!"
-    #   end
-    # or
-    #   before_attend :authorize # authorize is a helper method defined using helpers
-    #
-    # Stop execution using - throw :halt
-    #   before_attend do
-    #     throw :halt, 401 unless has_access?
-    #   end
-    # Throw a Symbol to execute a helper method
-    # Throw a String to render it as the content
-    # Throw a Fixnum to set the status
-    #
-    def before_attend(filter_name = nil, &block)
-      Sinatra::Event.before_attend(filter_name, &block)
-    end
-
-    # Run given block after each Event's execution
-    # Example:
-    #   after_attend do
-    #     logger.debug "After event attend!"
-    #   end
-    # or 
-    #   after_attend :clean_up  # clean_up is a helper method defined using helpers
-    #
-    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 environment is equal to env (Used for configuration)
-    def config_for(env = :development)
-      yield if Sinatra::Options.environment == env.to_sym
-    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

data/lib/sinatra/environment.rb

@@ -1,15 +0,0 @@
-module Sinatra
-  module Environment
-    extend self
-        
-    def prepare
-      Options.parse!(ARGV)
-    end
-
-    def prepare_loggers(logger = Logger.new(open(Options.log_file, 'w')))
-      [Server, EventContext, Event, Dispatcher].each do |klass|
-        klass.logger = logger
-      end
-    end    
-  end
-end

data/lib/sinatra/event.rb

@@ -1,238 +0,0 @@
-require 'thread'
-
-module Sinatra
-  
-  module EventManager # :nodoc:
-    extend self
-
-    def reset!
-      @events.clear if @events
-    end
-
-    def events
-      @events || []
-    end
-    
-    def register_event(event)
-      (@events ||= []) << event
-    end
-    
-    def determine_event(verb, path, if_nil = :present_error)
-      event = events.find(method(if_nil)) do |e|
-        e.verb == verb && e.recognize(path)
-      end
-    end
-    
-    def present_error
-      determine_event(:get, '404', :not_found)
-    end
-    
-    def not_found
-      Event.new(:get, 'not_found', false) do
-        status 404
-    
-        if request.path_info == '/' && request.request_method == 'GET'
-          erb :default_index, :views_directory => SINATRA_ROOT + '/files'
-        else
-          erb :not_found, :views_directory => SINATRA_ROOT + '/files'
-        end
-      end
-    end
-    
-  end
-    
-  class Event # :nodoc:
-
-    cattr_accessor :logger
-    cattr_accessor :after_filters
-    cattr_accessor :before_filters
-    
-    @@mutex = Mutex.new
-    
-    self.before_filters = []
-    self.after_filters = []
-    
-    def self.before_attend(method_name = nil, &block)
-      setup_filter(:before_filters, method_name, &block)
-    end
-
-    def self.after_attend(method_name = nil, &block)
-      setup_filter(:after_filters, method_name, &block)
-    end
-    
-    def self.setup_filter(filter_set_name, method_name, &block)
-      raise "Must specify method or block" if method_name.nil? and !block_given?
-      send(filter_set_name) << if block_given?
-        block
-      else
-        method_name
-      end
-    end
-      
-    after_attend :log_event
-    
-    attr_reader :path, :verb
-    
-    def initialize(verb, path, register = true, &block)
-      @verb = verb
-      @path = path
-      @route = Route.new(path)
-      @block = block
-      EventManager.register_event(self) if register
-    end
-    
-    def attend(request)
-      request.params.merge!(@route.params)
-      context = EventContext.new(request)
-      run_safely do
-        caught = catch(:halt) do
-          call_filters(before_filters, context)
-        end
-        body = case caught
-          when :filter_chain_completed
-            begin
-              context.instance_eval(&@block) if @block
-            rescue => e
-              context.error e
-            end
-          when Symbol
-            context.send(caught)
-          when String
-            caught
-          when Fixnum
-            context.status caught
-        end
-        context.body context.body || body || ''
-        call_filters(after_filters, context)
-      end
-      context
-    end
-    alias :call :attend
-
-    def recognize(path)
-      @route.recognize(path)
-    end
-
-    private
-    
-      def run_safely
-        if Options.use_mutex?
-          @@mutex.synchronize do
-            yield
-          end
-        else
-          yield
-        end
-      end
-      
-      # Adapted from Merb
-      # calls a filter chain according to rules.
-      def call_filters(filter_set, context)
-        filter_set.each do |filter|
-          case filter
-            when Symbol, String
-             context.send(filter)
-            when Proc
-             context.instance_eval(&filter)
-          end
-        end
-        :filter_chain_completed
-      end
-      
-  end
-  
-  class StaticEvent < Event # :nodoc:
-    
-    def initialize(path, root, register = true)
-      @root = root
-      super(:get, path, register)
-    end
-
-    def recognize(path)
-      filename = physical_path_for(path)
-      File.exists?(filename) && File.file?(filename)
-    end
-    
-    def physical_path_for(path)
-      path.gsub(/^#{@path}/, @root)
-    end
-    
-    def attend(request)
-      @filename = physical_path_for(request.path_info)
-      context = EventContext.new(request)
-      context.body self
-      context.header 'Content-Type' => MIME_TYPES[File.extname(@filename)[1..-1]]
-      context.header 'Content-Length' => File.size(@filename).to_s
-      context
-    end
-    
-    def each
-      File.open(@filename, "rb") do |file|
-        while part = file.read(8192)
-          yield part
-        end
-      end
-    end
-    
-    # :stopdoc:
-    # From WEBrick.
-    MIME_TYPES = {
-      "ai"    => "application/postscript",
-      "asc"   => "text/plain",
-      "avi"   => "video/x-msvideo",
-      "bin"   => "application/octet-stream",
-      "bmp"   => "image/bmp",
-      "class" => "application/octet-stream",
-      "cer"   => "application/pkix-cert",
-      "crl"   => "application/pkix-crl",
-      "crt"   => "application/x-x509-ca-cert",
-     #"crl"   => "application/x-pkcs7-crl",
-      "css"   => "text/css",
-      "dms"   => "application/octet-stream",
-      "doc"   => "application/msword",
-      "dvi"   => "application/x-dvi",
-      "eps"   => "application/postscript",
-      "etx"   => "text/x-setext",
-      "exe"   => "application/octet-stream",
-      "gif"   => "image/gif",
-      "htm"   => "text/html",
-      "html"  => "text/html",
-      "jpe"   => "image/jpeg",
-      "jpeg"  => "image/jpeg",
-      "jpg"   => "image/jpeg",
-      "lha"   => "application/octet-stream",
-      "lzh"   => "application/octet-stream",
-      "mov"   => "video/quicktime",
-      "mpe"   => "video/mpeg",
-      "mpeg"  => "video/mpeg",
-      "mpg"   => "video/mpeg",
-      "pbm"   => "image/x-portable-bitmap",
-      "pdf"   => "application/pdf",
-      "pgm"   => "image/x-portable-graymap",
-      "png"   => "image/png",
-      "pnm"   => "image/x-portable-anymap",
-      "ppm"   => "image/x-portable-pixmap",
-      "ppt"   => "application/vnd.ms-powerpoint",
-      "ps"    => "application/postscript",
-      "qt"    => "video/quicktime",
-      "ras"   => "image/x-cmu-raster",
-      "rb"    => "text/plain",
-      "rd"    => "text/plain",
-      "rtf"   => "application/rtf",
-      "sgm"   => "text/sgml",
-      "sgml"  => "text/sgml",
-      "tif"   => "image/tiff",
-      "tiff"  => "image/tiff",
-      "txt"   => "text/plain",
-      "xbm"   => "image/x-xbitmap",
-      "xls"   => "application/vnd.ms-excel",
-      "xml"   => "text/xml",
-      "xpm"   => "image/x-xpixmap",
-      "xwd"   => "image/x-xwindowdump",
-      "zip"   => "application/zip",
-    }
-    # :startdoc:
-  
-  end  
-  
-end

data/lib/sinatra/irb.rb

@@ -1,56 +0,0 @@
-module Sinatra
-  
-  #  Sinatra Irb is entered via <tt>ruby myapp.rb -c</tt> (replace myapp.rb with your app filename)
-  #
-  #  Be sure to also check out Sinatra::TestMethods for more cool stuff when your in Irb
-  #
-  module Irb
-    extend self
-
-    # taken from merb
-    def start! #:nodoc:
-      
-      Object.send(:include, TestMethods) # added to allow post_to in console
-      
-      Object.class_eval do
-        # Reload all Sinatra and App specific files
-        def reload!
-          Loader.reload!
-        end
-        
-        # Show the +body+ with result info in your text editor!!! Great Job!
-        def show!(editor = nil)
-          editor = editor || ENV['EDITOR']
-          IO.popen(editor, 'w') do |f| 
-            f.puts "<!--"
-            f.puts result_info
-            f.puts "-->"
-            f.puts
-            f.puts body
-          end
-          nil
-        end
-        alias :mate :show!
-        
-        def result_info #:nodoc:
-          info = <<-end_info
-          # Status: #{status}
-          # Headers: #{headers.inspect}
-          end_info
-        end
-      end
-      
-      ARGV.clear # Avoid passing args to IRB 
-      require 'irb' 
-      require 'irb/completion' 
-      def exit
-        exit!
-      end   
-      if File.exists? ".irbrc"
-        ENV['IRBRC'] = ".irbrc"
-      end
-      IRB.start
-      exit!
-    end
-  end
-end