merb 0.0.6 → 0.0.7

data/lib/merb/mixins/javascript_mixin.rb

@@ -0,0 +1,63 @@
+module Merb
+  module JavascriptMixin
+  
+    # escape text for javascript.
+    def escape_js(javascript)
+      (javascript || '').gsub('\\','\0\0').gsub(/\r\n|\n|\r/, "\\n").gsub(/["']/) { |m| "\\#{m}" }
+    end
+    
+    def link_to_function(name, function)
+      %{<a href="#" onclick="#{function}; return false;">#{name}</a>}
+    end
+    
+    def js(data)
+      if data.respond_to? :to_json
+        data.to_json
+      else
+        data.inspect.to_json
+      end
+    end
+    
+    def require_js(*scripts)
+      return nil if scripts.empty?
+      scripts.inject('') do |memo,script|
+        script = script.to_s
+        memo << %Q|<script src="/javascripts/#{script=~/\.js$/ ? script : script+'.js' }" type="text/javascript">//</script>\n|
+      end
+    end
+    
+    def require_css(*scripts)
+      return nil if scripts.empty?
+      scripts.inject('') do |memo,script|
+        script = script.to_s
+        memo << %Q|<link href="/stylesheets/#{script=~/\.css$/ ? script : script+'.css' }" media="all" rel="Stylesheet" type="text/css"/>\n|
+      end
+    end
+    
+    def js_hash(options)
+      '{' + options.map {|k, v| "#{k}:#{v}"}.join(', ') + '}'
+    end
+    
+    def insert_html(id, html, options = {})
+      position = options.fetch(:where, :before)
+      "new Insertion.#{position.to_s.camel_case}('#{id}', '#{escape_js html}');"
+    end
+  
+    def replace_html(id, html, options = {})
+      "Element.update('#{id}', '#{escape_js html}');"
+    end
+    
+    def hide(id)
+      "$('#{id}').style.display = 'none';"
+    end
+    
+    def show(id)
+      "$('#{id}').style.display = 'block';"
+    end
+  
+    def toggle(id)
+      "Element.toggle('#{id}');"
+    end
+    
+  end  
+end

data/lib/merb/mixins/render_mixin.rb

@@ -1,75 +1,91 @@
-module RenderMixin
+module Merb
 
-  # shortcut to a template path based on name.
-  def template_dir(loc)
-    File.expand_path(Merb::Server.config[:merb_root] + "/dist/app/views/#{loc}")
-  end  
-  
-  # returns the current method name. Used for
-  # auto discovery of which template to render
-  # based on the action name.
-  def current_method_name(depth=0)
-    caller[depth] =~ /`(.*)'$/; $1
-  end
-  
-  # does a render with no layout. Also sets the
-  # content type header to text/javascript and
-  # escapes the template for javascript eval on
-  # the client
-  def render_js(template=current_method_name(1), b=binding)
-    headers['Content-Type'] = "text/javascript"
-    template = Erubis::Eruby.new(IO.read( template_dir(self.class.name.snake_case) + "/#{template}.merbjs" )) 
-    template.result(b)
-  end
-  
-  # set the @layout. Use this right before a render to
-  # set the name of the layout to use minus the .rhtml
-  def layout(l)
-     @layout = l 
-  end
+  module RenderMixin
   
-  def render_nothing(status)
-    @status = status
-    return ''
-  end
-  
-  # renders the action without wrapping it in a layout.
-  def render_no_layout(template=current_method_name(1), b=binding)
-    template = Erubis::Eruby.new( IO.read( template_dir(self.class.name.snake_case) + "/#{template}.rhtml" ) ) 
-    template.result(b)
-  end 
-  
-  def partial(template)
-    template = Erubis::Eruby.new( IO.read( template_dir(self.class.name.snake_case) + "/_#{template}.rhtml" ) ) 
-    template.result(binding)
-  end 
-  
-  # renders a template based on the current action name
-  # you can pass the name of a template if you want to
-  # render a template with a different name then then 
-  # current action name. Wraps the rendered template in
-  # the layout. Uses layout/application.rhtml unless
-  # there is a layout named after the current controller
-  # or @layout has been set to another value.
-  def render(template=current_method_name(1), b=binding)
-    MERB_LOGGER.info("Rendering template: #{template_dir(template)}")
-    name = self.class.name.snake_case
-    template = Erubis::Eruby.new( IO.read( template_dir(name) + "/#{template}.rhtml" ) ) 
-    layout_content = template.result(b)
-    return layout_content if (@layout.to_s == 'none')
-    if ['application', name].include?(@layout.to_s)
-      if File.exist?(template_dir("layout/#{name}.rhtml"))
-        layout = name
+    # shortcut to a template path based on name.
+    def template_dir(loc)
+      File.expand_path(Merb::Server.config[:merb_root] + "/dist/app/views/#{loc}")
+    end  
+    
+    # returns the current method name. Used for
+    # auto discovery of which template to render
+    # based on the action name.
+    def current_method_name(depth=0)
+      caller[depth] =~ /`(.*)'$/; $1
+    end
+    
+    def template_extension_for(ext)
+      Merb::Server.config[:template_ext][ext]
+    end
+    
+    # does a render with no layout. Also sets the
+    # content type header to text/javascript
+    def render_js(template=current_method_name(1), b=binding)
+      headers['Content-Type'] = "text/javascript"
+      template = Erubis::Eruby.new(IO.read( template_dir(self.class.name.snake_case) + "/#{template}.#{template_extension_for(:js)}" )) 
+      template.result(b)
+    end
+    
+    # set the @layout. Use this right before a render to
+    # set the name of the layout to use minus the .rhtml
+    def layout(l)
+       @layout = l 
+    end
+    
+    # renders nothing but sets the status
+    def render_nothing(status=200)
+      @status = status
+      return "\n"
+    end
+    
+    # renders the action without wrapping it in a layout.
+    def render_no_layout(template=current_method_name(1), b=binding)
+      template = Erubis::Eruby.new( IO.read( template_dir(self.class.name.snake_case) + "/#{template}.#{template_extension_for(:html)}" ) ) 
+      template.result(b)
+    end 
+    
+    def partial(template)
+      template = Erubis::Eruby.new( IO.read( template_dir(self.class.name.snake_case) + "/_#{template}.#{template_extension_for(:html)}" ) ) 
+      template.result(binding)
+    end 
+    
+    def render_xml(template=current_method_name(1))
+      xml = Builder::XmlMarkup.new :indent => 2
+      xml.instruct! :xml, :version=>"1.0", :encoding=>"UTF-8"
+      eval IO.read( template_dir(self.class.name.snake_case) + "/#{template}.#{template_extension_for(:xml)}" ) 
+      @headers['Content-Type'] = 'application/xml'
+      @headers['Encoding']     = 'UTF-8'
+      xml.target!
+    end
+    
+    # renders a template based on the current action name
+    # you can pass the name of a template if you want to
+    # render a template with a different name then then 
+    # current action name. Wraps the rendered template in
+    # the layout. Uses layout/application.rhtml unless
+    # there is a layout named after the current controller
+    # or @layout has been set to another value.
+    def render(template=current_method_name(1), b=binding)
+      tmpl_ext = template_extension_for(:html)
+      MERB_LOGGER.info("Rendering template: #{template_dir(template)}..#{tmpl_ext}")
+      name = self.class.name.snake_case
+      template = Erubis::Eruby.new( IO.read( template_dir(name) + "/#{template}.#{tmpl_ext}" ) ) 
+      layout_content = template.result(b)
+      return layout_content if (@layout.to_s == 'none')
+      if ['application', name].include?(@layout.to_s)
+        if File.exist?(template_dir("layout/#{name}.#{tmpl_ext}"))
+          layout = name
+        else
+          layout = 'application'
+        end
       else
-        layout = 'application'
+        layout = @layout.to_s
       end
-    else
-      layout = @layout.to_s
+      MERB_LOGGER.info("With Layout: #{template_dir('layout')}/#{layout}.#{tmpl_ext}")
+      @layout_content = layout_content
+      layout_tmpl = Erubis::Eruby.new( IO.read( "#{template_dir('layout')}/#{layout}.#{tmpl_ext}" ) )      
+      layout_tmpl.result(b)
     end
-    MERB_LOGGER.info("With Layout: #{template_dir('layout')}/#{layout}.rhtml")
-    @layout_content = layout_content
-    layout_tmpl = Erubis::Eruby.new( IO.read( template_dir('layout') + "/#{layout}.rhtml" ) )      
-    layout_tmpl.result(b)
-  end
-  
+    
+  end  
 end  

data/lib/merb/mixins/responder_mixin.rb

@@ -0,0 +1,38 @@
+module Merb
+  # Thanks to Chris Wanstrath
+  # use this in your controllers to switch output based on
+  # the HTTP_ACCEPT header. like so:
+  # respond_to do |type|
+  #   type.js { render_js }
+  #   type.html { render }
+  #   type.xml { @foo.to_xml }
+  #   type.yaml { @foo.to_yaml }
+  # end  
+  
+  module ResponderMixin
+    def respond_to
+      yield response = Response.new(@env['HTTP_ACCEPT'])
+      @headers['Content-Type'] = response.content_type
+      response.body
+    end
+
+    class Response
+      attr_reader :body, :content_type
+      def initialize(accept) @accept = accept end
+
+      TYPES = { 
+        :yaml => %w[application/yaml text/yaml],
+        :text => %w[text/plain],
+        :html => %w[text/html */* application/html],
+        :xml  => %w[application/xml]
+      }
+
+      def method_missing(method, *args)
+        if TYPES[method] && @accept =~ Regexp.union(*TYPES[method])
+          @content_type = TYPES[method].first 
+          @body = yield if block_given?
+        end
+      end
+    end
+  end
+end  

data/lib/merb/session/merb_drb_server.rb

@@ -0,0 +1,107 @@
+require 'drb'
+require 'thread'
+
+module Merb
+  
+  class DRbSession
+    
+    include DRbUndumped
+    
+    class << self
+
+      def setup(opts={})
+        @opts = opts
+        @sessions = Hash.new
+        @timestamps = Hash.new
+        @mutex = Mutex.new
+        @session_ttl = opts.fetch(:session_ttl, 15*60) # default 15 minutes
+        self
+      end
+      
+      def create(opts={})
+        self[opts[:sess_id]] = opts[:data]
+      end  
+      
+      def [](key)
+        @mutex.synchronize {
+          @timestamps[key] = Time.now
+          @sessions[key]
+        }
+      end  
+       
+      def []=(key, val) 
+        @mutex.synchronize {
+          @timestamps[key] = Time.now
+          @sessions[key] = val
+        } 
+      end
+      
+      def delete(key)
+        @mutex.synchronize {
+          @sessions.delete(key)
+        }
+      end
+      
+      def reap_old_sessions
+        @timestamps.each do |key,stamp|
+          if stamp + @session_ttl < Time.now
+            delete(key)
+          end  
+        end
+        GC.start
+      end  
+      
+      def sessions
+        @sessions
+      end  
+      
+    end # end singleton class
+    
+  end # end DRbSession
+  
+  # Keeps track of the status of all currently processing uploads
+  class UploadProgress
+    attr_accessor :debug
+    def initialize
+      @guard    = Mutex.new
+      @counters = {}
+    end
+
+    def check(upid)
+      @counters[upid].last rescue nil
+    end
+
+    def last_checked(upid)
+      @counters[upid].first rescue nil
+    end
+
+    def update_checked_time(upid)
+      @guard.synchronize { @counters[upid][0] = Time.now }
+    end
+
+    def add(upid, size)
+      @guard.synchronize do
+        @counters[upid] = [Time.now, {:size => size, :received => 0}]
+        puts "#{upid}: Added" if @debug
+      end
+    end
+
+    def mark(upid, len)
+      return unless status = check(upid)
+      puts "#{upid}: Marking" if @debug
+      @guard.synchronize { status[:received] = status[:size] - len }
+    end
+
+    def finish(upid)
+      @guard.synchronize do
+        puts "#{upid}: Finished" if @debug
+        @counters.delete(upid)
+      end
+    end
+
+    def list
+      @counters.keys.sort
+    end
+  end
+  
+end  

data/lib/merb/session/merb_drb_session.rb

@@ -0,0 +1,71 @@
+module Merb
+  
+  module SessionMixin
+
+    def setup_session
+      MERB_LOGGER.info("Setting up session")
+      @session = Merb::Session.persist(cookies)
+      @fingerprint_before = Marshal.dump(@session).hash
+    end
+
+    def finalize_session
+      MERB_LOGGER.info("Finalize session")
+      unless Marshal.dump(@session).hash == @fingerprint_before
+        @session.save
+      end
+      @headers['Set-Cookie'] = @cookies.map { |k,v| "#{k}=#{escape(v)}; path=/" if v != @k[k] } - [nil]
+    end 
+
+    # accessor for @session. Please use session and 
+    # never @session directly.    
+    def session
+      @session  
+    end
+
+  end
+  
+  class Session
+  
+    attr_reader :sess_id
+  
+    def []=(k, v) # :nodoc:
+        (@data||={})[k] = v rescue nil
+    end
+    def [](k) # :nodoc:
+        @data[k] rescue nil
+    end
+  
+    def initialize(sess_id,data={})
+      @data = data || {}
+      @sess_id = sess_id
+    end  
+    
+    def save
+      Merb::DRbSession[@sess_id] = @data
+    end  
+  
+    RAND_CHARS = [*'A'..'Z'] + [*'0'..'9'] + [*'a'..'z']
+  
+    # Generates a new session ID and creates a row for the new session in the database.
+    def self.generate(cookies)
+      rand_max = RAND_CHARS.size
+      sid = (0...32).inject("") { |ret,_| ret << RAND_CHARS[rand(rand_max)] }
+      sess = Merb::DRbSession.create(:sess_id => sid, :data => {})
+      cookies[:sess_id] = sid
+      new(sid, sess)
+    end
+  
+    # Gets the existing session based on the <tt>camping_sid</tt> available in cookies.
+    # If none is found, generates a new session.
+    def self.persist cookies
+      if cookies[:sess_id]
+        session = new(cookies[:sess_id], Merb::DRbSession[cookies[:sess_id]])
+      end
+      unless session
+        session = Merb::Session.generate(cookies)
+      end
+      session
+    end
+  end
+  
+end  

data/lib/merb/session/merb_session.rb

@@ -1,3 +1,4 @@
+require 'active_record'
 module Merb
   module SessionMixin