rambo 0.5.2

data/README

@@ -0,0 +1,32 @@
+To install the gem:
+
+gem sources -a http://gems.github.com
+sudo gem install moomerman-rambo
+
+Smallest example (see the hello app in the example folder)
+
+class HomeController < Rambo::Controller
+  def index
+    "hello world"
+  end
+end
+
+To run the Blog example:
+
+git clone git://github.com/moomerman/rambo.git
+cd rambo/example/blog/
+rake db:setup # check config.yml for your specific db settings
+rake server
+
+head over to http://localhost:4000/
+
+Features:
+    = No Ruby object base class modifications
+    = Lightweight and fast
+    = Rack-based so works with most web servers (thin, mongrel, passenger)
+    = Ability to proxy request to n backend app servers [experimental]
+    = Request caching built in
+    = fast static file serving
+    = works with erb or haml templates (more to come)
+    = DataMapper integration
+    = Library only 60k

data/lib/rambo.rb

@@ -0,0 +1,4 @@
+require 'rambo/server'
+
+module Rambo
+end

data/lib/rambo/application_context.rb

@@ -0,0 +1,52 @@
+module Rambo
+  class ApplicationContext
+    attr_accessor :application_name
+    
+    def initialize(application_name = nil)
+      @application_name = application_name
+      puts "Initializing application: #{application_name || 'default'}"
+      @prefix = "#{self.application_name}/" if self.application_name
+      @prefix ||= ''
+      load_classes
+    end
+    
+    def load_classes
+      Dir["#{@prefix}controller/*.rb"].each { |x| funkyload x; }
+      Dir["#{@prefix}model/*.rb"].each { |x| funkyload x }
+      Dir["#{@prefix}lib/*.rb"].each { |x| funkyload x }
+      Dir["#{@prefix}*.rb"].each { |x| funkyload x unless x == 'Rakefile.rb' }
+    end
+    
+    def reload
+      load_classes
+    end
+    
+    def view_path
+      "./#{@prefix}view"
+    end
+    
+    private
+      def funkyload(file)
+        @@loadcache ||= {}
+        begin
+          if cache = @@loadcache[file]
+            return if Env.config['rambo'] and Env.config['rambo']['reload_classes'] == false
+            if (mtime = File.mtime(file)) > cache
+              puts "rambo: reloading: #{file}"
+              load file
+              @@loadcache[file] = mtime
+            end
+          else
+            puts " ->  loading: #{file}"
+            load file
+            @@loadcache[file] = File.mtime(file)
+          end
+        rescue Exception => e
+          puts "Exception loading class [#{file}]: #{e.message}"
+          puts e.backtrace.join("\n")
+          raise e
+        end
+      end
+    
+  end
+end

data/lib/rambo/application_request.rb

@@ -0,0 +1,25 @@
+module Rambo
+  class ApplicationRequest < Rambo::Request
+    
+    def initialize(env)
+      super
+    end
+    
+    def application
+      path_components[1]
+    end
+    
+    def controller
+      path_components[2] || default_controller
+    end
+  
+    def action
+      path_components[3] || 'index'
+    end
+    
+    def controller_class
+      self.application.gsub(/^[a-z]|\s+[a-z]/) { |a| a.upcase } + '::' + super
+    end
+    
+  end
+end

data/lib/rambo/controller.rb

@@ -0,0 +1,36 @@
+require 'rambo/controller/template'
+require 'rambo/controller/cache'
+require 'rambo/controller/params'
+require 'rambo/controller/redirect'
+
+module Rambo
+  class Controller
+    attr_accessor :request, :response
+    
+    include Template
+    include Cache
+    include Params
+    include Redirect
+    
+    def already_rendered?
+      @rendered
+    end
+    
+    def controller
+      self.request.controller
+    end
+  
+    def action
+      self.request.action
+    end
+  
+    def session
+      request.env['rack.session'] ||= {}
+    end
+    
+    def host
+      self.request.env['HTTP_HOST']
+    end
+    
+  end
+end

data/lib/rambo/controller/cache.rb

@@ -0,0 +1,17 @@
+module Cache
+  def fresh?(model, options={})
+    @@etags ||= {}
+    etag = Digest::SHA1.hexdigest(model.inspect)
+    response.header['ETag'] = "\"#{etag}\""
+    response.header['Expires'] = (MooTime.now + options[:expires_in]).httpdate if options[:expires_in]
+    response.header['Cache-Control'] = 'public'
+    if @@etags[request.uri] == etag
+      response.status = 304
+      response.body = ''
+      return true
+    else
+      @@etags[request.uri] = etag
+      return false
+    end
+  end
+end

data/lib/rambo/controller/params.rb

@@ -0,0 +1,26 @@
+module Params
+  def params
+    if !self.request.params.keys.join.include?('[')
+      @params ||= indifferent_hash.merge(self.request.params)
+    else
+      @params ||= self.request.params.inject indifferent_hash do |res, (key,val)|
+        if key.include?('[')
+          head = key.split(/[\]\[]+/)
+          last = head.pop
+          head.inject(res){ |hash,k| hash[k] ||= indifferent_hash }[last] = val
+        else
+          res[key] = val
+        end
+        res
+      end
+    end
+    if request.path_components.size() > 2
+      @params.merge!(:id => request.path_components[3])
+    end
+    @params
+  end
+  
+  def indifferent_hash
+    Hash.new {|hash,key| hash[key.to_s] if Symbol === key }
+  end
+end

data/lib/rambo/controller/redirect.rb

@@ -0,0 +1,14 @@
+module Redirect
+  def redirect(destination, options={})
+    destination = destination.to_s if destination.is_a? Symbol
+    unless destination[0,1] == "/" or destination =~ /^http:\/\// or destination =~ /^file:\/\//
+      destination = "/#{self.controller}/#{destination}"
+    end
+    puts "redirecting to #{destination}"
+    
+    @rendered = true
+    response.status = 302
+    response.header['Location'] = destination
+    return ""
+  end
+end

data/lib/rambo/controller/template.rb

@@ -0,0 +1,80 @@
+module Template
+  
+  @@template_cache = {}
+  
+  def erb(template, options={}, locals={})
+    require 'erb' unless defined? ::ERB
+    render :erb, template, options, locals
+  end
+  
+  def haml(template, options={}, locals={})
+    require 'haml' unless defined? ::Haml
+    render :haml, template, options, locals
+  end
+  
+  private
+    def render(engine, template, options={}, locals={})
+      # extract generic options
+      layout = options.delete(:layout)
+      layout = :layout if layout.nil? || layout == true
+      views = options.delete(:views) || self.request.application_context.view_path
+      locals = options.delete(:locals) || locals || {}
+
+      # render template
+      data, options[:filename], options[:line] = lookup_template(engine, template, views)
+      output = __send__("render_#{engine}", data, options, locals)
+
+      # render layout
+      if layout
+        data, options[:filename], options[:line] = lookup_layout(engine, layout, views)
+        if data
+          output = __send__("render_#{engine}", data, options, locals) { output }
+        end
+      end
+
+      output
+    end
+ 
+    def lookup_template(engine, template, views_dir)
+      case template
+      when Symbol
+        # if cached = @@template_cache[template]
+        #   cached
+        # else
+          path = ::File.join(views_dir, "#{template}.#{engine}")
+          [ ::File.read(path), path, 1 ]
+        #  @@template_cache[template] = res
+        #  res
+        #end
+      when Proc
+        [template.call, template, 1]
+      when String
+        [template, template, 1]
+      else
+        raise ArgumentError
+      end
+    end
+ 
+    def lookup_layout(engine, template, views_dir)
+      lookup_template(engine, template, views_dir)
+    rescue Errno::ENOENT
+      nil
+    end
+ 
+    def render_erb(data, options, locals, &block)
+      original_out_buf = @_out_buf
+      data = data.call if data.kind_of? Proc
+ 
+      instance = ::ERB.new(data, nil, nil, '@_out_buf')
+      locals_assigns = locals.to_a.collect { |k,v| "#{k} = locals[:#{k}]" }
+ 
+      src = "#{locals_assigns.join("\n")}\n#{instance.src}"
+      eval src, binding, '(__ERB__)', locals_assigns.length + 1
+      @_out_buf, result = original_out_buf, @_out_buf
+      result
+    end
+    
+    def render_haml(data, options, locals, &block)
+      ::Haml::Engine.new(data, options).render(self, locals, &block)
+    end
+end

data/lib/rambo/env.rb

@@ -0,0 +1,43 @@
+# Env handles all the configuration loading, database initialization and class (re)loading
+# would be nice to allow the user to specify their own init though if they want
+# Env.new can be called anywhere in any application and therefore acts as a global config
+module Rambo
+  class Env
+    def self.config
+      @@config ||= YAML.load_file("config.yml") rescue nil
+      @@config ||= {}
+    end
+    
+    def initialize
+      begin
+        # TODO: config reload
+        
+        if dbconf = Env.config['mongodb']
+          require 'mongomapper'
+          @@database ||= MongoMapper.database = dbconf['database']
+        end
+        
+        if dbconf = Env.config['datamapper']
+          require 'dm-core'
+          require 'dm-validations'
+          require 'dm-timestamps'
+          @@connection ||= DataMapper.setup(
+            :default,
+            :adapter => :mysql, 
+            :host => dbconf['host'], 
+            :database => dbconf['database'], 
+            :username => dbconf['username'], 
+            :password => dbconf['password']
+          )
+          @@dblogger ||= DataObjects::Mysql.logger = DataObjects::Logger.new(STDOUT, dbconf['logging']) if dbconf['logging']
+        end
+      rescue Exception => e
+        puts "Exception initializing environment: #{e.message}"
+        puts e.backtrace.join("\n")
+        raise e
+      end
+      
+    end
+    
+  end
+end

data/lib/rambo/middleware.rb

@@ -0,0 +1,3 @@
+require 'rambo/middleware/lock'
+require 'rambo/middleware/proxy'
+require 'rambo/middleware/upload'

data/lib/rambo/middleware/lock.rb

@@ -0,0 +1,18 @@
+module Rack
+  class Lock
+    FLAG = 'rack.multithread'.freeze unless defined? FLAG
+    
+    def initialize(app, lock = Mutex.new)
+      @app, @lock = app, lock
+    end
+
+    def call(env)
+      old, env[FLAG] = env[FLAG], false
+      @lock.synchronize { @app.call(env) }
+    ensure
+      env[FLAG] = old
+    end
+    
+  end
+end
+

data/lib/rambo/middleware/proxy.rb

@@ -0,0 +1,48 @@
+require 'net/http'
+#require 'right_http_connection'
+
+module Rack
+  class Proxy
+    def initialize(app, options={})
+      @app = app
+      @options = options
+      @@conn = Rightscale::HttpConnection.new
+    end
+
+    def call(env)
+      
+      request = Request.new(env)
+      
+      # tey out persistent connections using right http conn (need to make params aware?)
+      
+      begin
+        
+        backend = rand(@options[:backend].size+1)
+        
+        if backend == @options[:backend].size
+          @app.call(env)
+        else
+          host = URI.parse("http://#{env['HTTP_HOST']}").host
+          port = @options[:backend][backend]
+      
+          req = Net::HTTP::Get.new(env['REQUEST_URI'])
+          res = Net::HTTP.start(host, port) {|http|
+             http.request(req, request.params)
+           }
+
+          # need to be able to pass params into request below
+          #res = @@conn.req(:server => host, :port => port, :protocol => 'http', :request => request)
+        
+          body = res.body || ''
+        
+          [res.code.to_i, {'ETag' => res['ETag'], 'Cache-Control' => res['Cache-Control'], 'Content-Type' => res['Content-Type'], 'Location' => res['Location']}, body]
+        end
+      rescue Exception => e
+        puts e.message
+        @app.call(env)
+      end
+    end
+    
+  end
+end
+

data/lib/rambo/middleware/upload.rb

@@ -0,0 +1,16 @@
+module Rack
+  class Upload
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      request = Rack::Request.new(env)
+      
+      #puts "UPLOAD SAYS HELLO"
+      
+      @app.call(env)
+    end
+  end
+end
+

data/lib/rambo/request.rb

@@ -0,0 +1,61 @@
+require 'rack'
+
+module Rambo
+  class Request < Rack::Request
+    def user_agent
+      @env['HTTP_USER_AGENT']
+    end
+
+    # Returns an array of acceptable media types for the response
+    def accept
+      @env['HTTP_ACCEPT'].to_s.split(',').map { |a| a.strip }
+    end
+  
+    def path
+      @env["REQUEST_PATH"]
+    end
+  
+    def uri
+      @env["REQUEST_URI"]
+    end
+  
+    def path_components
+      @path_components ||= path.split('/')
+    end
+    
+    def default_controller
+      if rambo_conf = Rambo::Env.config['rambo']
+        rambo_conf['default_controller'] || 'home'
+      else
+        'home'
+      end
+    end
+    
+    def application_context
+      @application_context
+    end
+    
+    def application_context=(ctx)
+      @application_context = ctx
+    end
+    
+    def controller
+      path_components[1] || default_controller
+    end
+  
+    def action
+      path_components[2] || 'index'
+    end
+    
+    def controller_class
+      self.controller.downcase.gsub(/^[a-z]|\s+[a-z]/) { |a| a.upcase } + 'Controller'
+    end
+    
+    # Override Rack 0.9.x's #params implementation (see #72 in lighthouse)
+    def params
+      self.GET.update(self.POST)
+    rescue EOFError => boom
+      self.GET
+    end
+  end
+end

data/lib/rambo/response.rb

@@ -0,0 +1,29 @@
+module Rambo
+  class Response < Rack::Response
+    def initialize
+      @status, @body = 200, []
+      @header = Rack::Utils::HeaderHash.new({'Content-Type' => 'text/html'})
+    end
+
+    # def write(str)
+    #   @body << str.to_s
+    #   str
+    # end
+    # 
+    # def finish
+    #   @body = block if block_given?
+    #   if [204, 304].include?(status.to_i)
+    #     header.delete "Content-Type"
+    #     [status.to_i, header.to_hash, []]
+    #   else
+    #     body = @body || []
+    #     body = [body] if body.respond_to? :to_str
+    #     if body.respond_to?(:to_ary)
+    #       header["Content-Length"] = body.to_ary.
+    #         inject(0) { |len, part| len + part.bytesize }.to_s
+    #     end
+    #     [status.to_i, header.to_hash, body]
+    #   end
+    # end
+  end
+end

data/lib/rambo/server.rb

@@ -0,0 +1,67 @@
+#!/usr/bin/env ruby
+
+require 'rambo/env'
+require 'rambo/controller'
+require 'rambo/middleware'
+require 'rambo/time'
+require 'rambo/request'
+require 'rambo/application_request'
+require 'rambo/response'
+require 'rambo/application_context'
+
+# Server simply routes the request to the correct controller/action and returns the result
+module Rambo
+  class Server
+    
+    def initialize(options = {})
+      @options = options
+      env = Rambo::Env.new
+      @contexts = {
+        'default' => Rambo::ApplicationContext.new(),
+        #'blog' => Rambo::ApplicationContext.new('blog')
+      }
+    end
+    
+    def call(env)
+      begin
+        
+        @contexts.each { |key, context| context.reload } if Rambo::Env.config
+        
+        request = Request.new(env)
+        response = Response.new
+        
+        if @contexts.keys.include? request.controller.downcase
+          current_context = @contexts[request.controller.downcase]
+          request = Rambo::ApplicationRequest.new(env)
+        end
+        current_context ||= @contexts['default']
+        request.application_context = current_context
+        
+        #puts "rambo: looking for #{request.controller_class}"
+        
+        begin
+          controller = Object.module_eval("::#{request.controller_class}", __FILE__, __LINE__).new
+        rescue Exception => e
+          return [404, response.header, "<h2>Routing error: controller <span style='color:grey'>#{request.controller}</span> not found</h2>"]
+        end
+        controller.request = request
+        controller.response = response
+        
+        controller.init if controller.respond_to? :init 
+        
+        unless controller.respond_to? request.action
+          return [404, response.header, "<h2>Routing error: action <span style='color:grey'>#{request.action}</span> not found in <span style='color:grey'>#{request.controller}</span></h2>"]
+        end
+        
+        result = controller.send(request.action) unless controller.already_rendered?
+        
+        response.body = result if result
+        
+        [response.status, response.header, response.body]
+      rescue Exception => e
+        puts e.message
+        return [500, {}, "<pre><b>#{e.message.gsub("<","&lt;")}</b>\n#{e.backtrace.join("\n")}</pre>"]
+      end
+    end
+  end
+end

data/lib/rambo/time.rb

@@ -0,0 +1,11 @@
+class MooTime < Time
+  RFC2822_DAY_NAME  	=  	[ 'Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat' ]
+  RFC2822_MONTH_NAME 	= 	[ 'Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec' ]
+  def httpdate
+      t = dup.utc
+      sprintf('%s, %02d %s %d %02d:%02d:%02d GMT',
+        RFC2822_DAY_NAME[t.wday],
+        t.day, RFC2822_MONTH_NAME[t.mon-1], t.year,
+        t.hour, t.min, t.sec)
+    end
+end

metadata

@@ -0,0 +1,73 @@
+--- !ruby/object:Gem::Specification 
+name: rambo
+version: !ruby/object:Gem::Version 
+  version: 0.5.2
+platform: ruby
+authors: 
+- Richard Taylor
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-12-30 00:00:00 +00:00
+default_executable: 
+dependencies: []
+
+description: rambo is an experimental ruby web framework
+email: moomerman@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- README
+- lib/rambo.rb
+- lib/rambo/application_context.rb
+- lib/rambo/application_request.rb
+- lib/rambo/controller/cache.rb
+- lib/rambo/controller/params.rb
+- lib/rambo/controller/redirect.rb
+- lib/rambo/controller/template.rb
+- lib/rambo/controller.rb
+- lib/rambo/env.rb
+- lib/rambo/middleware/lock.rb
+- lib/rambo/middleware/proxy.rb
+- lib/rambo/middleware/upload.rb
+- lib/rambo/middleware.rb
+- lib/rambo/request.rb
+- lib/rambo/response.rb
+- lib/rambo/server.rb
+- lib/rambo/time.rb
+has_rdoc: true
+homepage: http://github.com/moomerman/rambo
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --inline-source
+- --charset=UTF-8
+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: rambo
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: rambo is an experimental ruby web framework based on rack
+test_files: []
+