sinatra 0.1.0

data/lib/sinatra/environment.rb

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

@@ -0,0 +1,184 @@
+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
+    
+    self.after_filters = []
+    
+    def self.after_attend(filter)
+      after_filters << filter
+    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)
+      begin
+        result = context.instance_eval(&@block) if @block
+        context.body context.body || result || ''
+      rescue => e
+        context.error e
+      end
+      run_through_after_filters(context)
+      context
+    end
+    alias :call :attend
+
+    def recognize(path)
+      @route.recognize(path)
+    end
+
+    private
+    
+      def run_through_after_filters(context)
+        after_filters.each { |filter| context.send(filter) }
+      end
+      
+  end
+  
+  class StaticEvent < Event # :nodoc:
+    
+    def initialize(path, root, register = true)
+      @root = root
+      super(:get, path, register)
+    end
+
+    def recognize(path)
+      File.exists?(physical_path_for(path))
+    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

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

data/lib/sinatra/loader.rb

@@ -0,0 +1,31 @@
+require 'set'
+
+module Sinatra
+  module Loader
+    extend self
+
+    def reload!
+      silence_warnings do
+        EventManager.reset!
+        load_files loaded_files
+        load $0
+      end
+    end
+
+    def load_files(*files)
+      files = files.flatten
+      files = files.first if files.first.is_a? Set
+
+      files.each do |file| 
+        file = File.expand_path(file)
+        load file
+        loaded_files << file
+      end
+    end
+    alias_method :load_file, :load_files
+
+    def loaded_files
+      @loaded_files ||= Set.new
+    end
+  end
+end 

data/lib/sinatra/logger.rb

@@ -0,0 +1,22 @@
+module Sinatra
+  
+  class Logger
+    
+    def initialize(steam)
+      @stream = steam
+    end
+    
+    %w(info debug error warn).each do |n|
+      define_method n do |message|
+        @stream.puts message
+        @stream.flush
+      end
+    end
+    
+    def exception(e)
+      error "#{e.message}:\n\t#{e.backtrace.join("\n\t")}"
+    end
+    
+  end
+  
+end

data/lib/sinatra/options.rb

@@ -0,0 +1,43 @@
+require 'optparse'
+
+module Sinatra
+  module Options
+    extend self
+    
+    attr_with_default :port, 4567
+    attr_with_default :environment, :development
+    attr_with_default :console, nil
+
+    def parse!(args)
+      return if @environment == :test
+      OptionParser.new do |opts|
+        opts.on '-p port', '--port port', 'Set the port (default is 4567)' do |port|
+          @port = port
+        end
+        opts.on '-e environment', 'Set the environment (default if development)' do |env|
+          @environment = env.intern
+        end
+        opts.on '-c', '--console', 'Run in console mode' do
+          @console = true
+        end
+        opts.on '-h', '--help', '-?', 'Show this message' do
+          puts opts
+          exit!
+        end
+      end.parse!(ARGV)
+    end
+    
+    def log_file
+      # TODO find a better way that this
+      if File.basename($0, '.rb') == 'rake_test_loader'  # hack to satisfy rake
+        '%s.log' % environment
+      else
+        File.dirname($0) + ('/%s.log' % environment)
+      end
+    end
+    
+    def set_environment(env)
+      @environment = env
+    end
+  end
+end

data/lib/sinatra/rack_ext/request.rb

@@ -0,0 +1,15 @@
+module Rack #:nodoc:
+  
+  class Request #:nodoc:
+    
+    def request_method
+      if @env['REQUEST_METHOD'] == 'POST' && %w(PUT DELETE).include?(params['_method'])
+        params['_method'].upcase
+      else
+        @env['REQUEST_METHOD']
+      end
+    end
+    
+  end
+  
+end

data/lib/sinatra/route.rb

@@ -0,0 +1,65 @@
+module Sinatra
+
+  class Route
+
+    SYMBOL_FIND = /:[a-z_]+/.freeze
+    PARENTHETICAL_SEGMENT_STRING = "([^\/.,;?]+)".freeze
+
+    attr_reader :regex, :params
+
+    def initialize(template)
+      @template = template.to_s.strip
+      @default_params = { :format => 'html' }
+      @params = {}
+      extract_keys
+      genereate_route
+    end
+  
+    def recognize(path)
+      @params.clear
+      
+      param_values = path.match(@regex).captures.compact rescue nil
+            
+      if param_values
+        keys = @keys.size < param_values.size ? @keys.concat([:format]) : @keys
+        @params = @default_params.merge(@keys.zip(param_values).to_hash)
+        true
+      else
+        false
+      end
+    end
+
+    private
+    
+      def extract_keys
+        @keys = @template.scan(SYMBOL_FIND).map { |raw| eval(raw) }
+        @keys
+      end
+
+      def genereate_route_without_format
+        template = @template.dup
+        template.gsub!(/\.:format$/, '')
+        to_regex_route(template)
+      end
+
+      def genereate_route_with_format
+        template = @template.dup
+        if template =~ /\.:format$|\.([\w\d]+)$/
+          @default_params[:format] = $1 if $1
+        else
+          template << '.:format'
+        end
+        to_regex_route(template)
+      end
+  
+      def to_regex_route(template)
+        /^#{template.gsub(/\./, '\.').gsub(SYMBOL_FIND, PARENTHETICAL_SEGMENT_STRING)}$/
+      end
+
+      def genereate_route
+        @regex = Regexp.union(genereate_route_without_format, genereate_route_with_format)
+      end
+
+  end
+
+end

data/lib/sinatra/server.rb

@@ -0,0 +1,54 @@
+require 'fileutils'
+
+module Sinatra
+  
+  class Server
+    
+    cattr_accessor :logger
+    cattr_accessor :running
+    
+    def start
+      begin
+        tail_thread = tail(Options.log_file)
+        Rack::Handler::Mongrel.run(Sinatra::Session::Cookie.new(Dispatcher.new), :Port => Options.port) do |server|
+          puts "== Sinatra has taken the stage on port #{server.port}!"
+          trap("INT") do
+            server.stop
+            self.class.running = false
+            puts "\n== Sinatra has ended his set (crowd applauds)"
+          end
+        end
+        self.class.running = true
+      rescue => e
+        logger.exception e
+      ensure
+        tail_thread.kill if tail_thread
+      end
+    end
+        
+    private 
+        
+      def tail(log_file)
+        FileUtils.touch(log_file)
+        cursor = File.size(log_file)
+        last_checked = Time.now
+        tail_thread = Thread.new do
+          File.open(log_file, 'r') do |f|
+            loop do
+              f.seek cursor
+              if f.mtime > last_checked
+                last_checked = f.mtime
+                contents = f.read
+                cursor += contents.length
+                print contents
+              end
+              sleep 1
+            end
+          end
+        end
+        tail_thread
+      end
+      
+  end
+  
+end