moomerman-rambo 0.3

data/README

@@ -0,0 +1,12 @@
+To install the gem:
+
+gem sources -a http://gems.github.com
+sudo gem install moomerman-rambo
+
+To run the example:
+
+clone the repo (the examples are not part of the gem)
+cd rambo/example/blog/
+thin start -R server.ru -p 4000 --threaded
+
+head over to http://localhost:4000/

data/lib/rambo/base_controller.rb

@@ -0,0 +1,71 @@
+load 'rambo/templating.rb'
+
+module Rambo
+  class BaseController
+    include Templating
+  
+    attr_accessor :params, :request, :response
+
+    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 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
+  
+    def controller
+      self.request.controller
+    end
+  
+    def action
+      self.request.action
+    end
+  
+    def indifferent_hash
+      Hash.new {|hash,key| hash[key.to_s] if Symbol === key }
+    end
+  
+    def redirect(destination, options={})
+      destination = destination.to_s if destination.is_a? Symbol
+      unless destination[0,1] == "/"
+        destination = "/#{self.controller}/#{destination}"
+      end
+      puts "redirecting to #{destination}"
+    
+      response.status = 302
+      response.header['Location'] = destination
+      return ""
+    end
+  
+  end
+end

data/lib/rambo/lock.rb

@@ -0,0 +1,18 @@
+module Rack
+  class Lock
+    FLAG = 'rack.multithread'.freeze
+    
+    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/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/request.rb

@@ -0,0 +1,39 @@
+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 controller
+      path_components[1] || 'home'
+    end
+  
+    def action
+      path_components[2] || 'index'
+    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,80 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'thin'
+
+require 'rambo/lock'
+require 'rambo/proxy'
+require 'rambo/templating'
+require 'rambo/base_controller'
+require 'rambo/time'
+require 'rambo/upload'
+require 'rambo/request'
+require 'rambo/response'
+
+module Rambo
+  class Server
+  
+    def initialize(options = {})
+      @options = options
+      # load from config - only do this IF database required
+      require 'dm-core'
+      require 'dm-validations'
+      require 'dm-timestamps'
+      #DataMapper.setup(:default, 'mysql://localhost/moo_development')
+      DataMapper.setup(:default, :adapter => :mysql, :host => 'localhost', :database => 'moo_development', :username => 'root', :password => '')
+      #DataObjects::Mysql.logger = DataObjects::Logger.new(STDOUT, :debug)
+    end
+  
+    def call(env)
+      begin
+        Dir["controller/*.rb"].each { |x| funkyload x }
+        Dir["model/*.rb"].each { |x| funkyload x }
+        Dir["lib/*.rb"].each { |x| funkyload x }
+      
+        request = Request.new(env)
+        response = Response.new
+      
+        ctl_string = (request.controller.downcase.gsub(/^[a-z]|\s+[a-z]/) { |a| a.upcase } + 'Controller')
+        begin
+          obj = Object.module_eval("::#{ctl_string}", __FILE__, __LINE__).new
+        rescue Exception => e
+          return [404, response.header, "<h1>Controller #{ctl_string} Not Found</h1>"]
+        end
+        obj.request = request
+        obj.response = response
+      
+        #begin
+          result = obj.send(request.action)
+        #rescue Exception => e
+          #return [404, response.header, "<h1>Action #{request.action} Not Found</h1>"]
+        #end
+        response.body = result if result
+      
+        [response.status, response.header, response.body]
+      rescue Exception => e
+        puts e.message
+        return [500, response.header, "<pre><b>#{e.message.gsub("<","&lt;")}</b>\n#{e.backtrace.join("\n")}</pre>"]
+      end
+    end
+  
+    private
+      # turn this into a thread that checks every x seconds
+      # (any chance of a callback?) so it is outside of the 
+      # request/response cycle
+      def funkyload(file)
+        @@loadcache ||= {}
+        if cache = @@loadcache[file] 
+          if (mtime = File.mtime(file)) > cache
+            puts "reloading: #{file}"
+            load file
+            @@loadcache[file] = mtime
+          end
+        else
+          puts "loading: #{file}"
+          load file
+          @@loadcache[file] = File.mtime(file)
+        end
+      end
+  end
+end

data/lib/rambo/templating.rb

@@ -0,0 +1,68 @@
+module Templating
+  
+  @@template_cache = {}
+  
+  def erb(template, options={}, locals={})
+    require 'erb' unless defined? ::ERB
+    render :erb, 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) || "./view"
+      locals = options.delete(:locals) || locals || {}
+ 
+      # render template
+      data = lookup_template(engine, template, views)
+      output = __send__("render_#{engine}", template, data, options, locals)
+ 
+      # render layout
+      if layout && data = lookup_layout(engine, layout, views)
+        __send__("render_#{engine}", layout, data, options, {}) { output }
+      else
+        output
+      end
+    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}")
+          res = ::File.read(path)
+        #  @@template_cache[template] = res
+        #  res
+        #end
+      when Proc
+        template.call
+      when String
+        template
+      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(template, 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
+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

data/lib/rambo/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.rb

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

metadata

@@ -0,0 +1,84 @@
+--- !ruby/object:Gem::Specification 
+name: moomerman-rambo
+version: !ruby/object:Gem::Version 
+  version: "0.3"
+platform: ruby
+authors: 
+- Richard Taylor
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-04-17 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: oauth
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.3.1
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: json
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.1.2
+    version: 
+description: rambo is an experimental ruby web framework
+email: moomerman@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- README
+- lib/rambo.rb
+- lib/rambo
+- lib/rambo/base_controller.rb
+- lib/rambo/lock.rb
+- lib/rambo/server.rb
+- lib/rambo/proxy.rb
+- lib/rambo/request.rb
+- lib/rambo/response.rb
+- lib/rambo/templating.rb
+- lib/rambo/time.rb
+- lib/rambo/upload.rb
+has_rdoc: false
+homepage: http://github.com/moomerman/rambo
+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.2.0
+signing_key: 
+specification_version: 2
+summary: rambo is an experimental ruby web framework
+test_files: []
+