raw 0.49.0

data/lib/raw/context/response.rb

@@ -0,0 +1,57 @@
+module Raw
+  
+# HTTP Response. This module is included in Context.
+
+module Response
+
+  # The Response status.
+
+  attr_accessor :status
+
+  # The Response headers.
+
+  attr_accessor :response_headers
+
+  # The Response cookies.
+
+  attr_accessor :response_cookies
+
+  # Return the content type for this response.
+  
+  def content_type
+    @response_headers["Content-Type"]
+  end
+
+  # Set the content type for this response.
+  
+  def content_type=(ctype)
+    @response_headers["Content-Type"] = ctype
+  end
+
+  # Add a cookie to the response. Better use this
+  # method to avoid precreating the cookies array
+  # for every request.
+  #
+  # === Examples
+  #
+  # add_cookie('nsid', 'gmosx')
+  # add_cookie(Cookie.new('nsid', 'gmosx')
+  
+  def add_cookie(cookie, value = nil)
+    if value
+      (@response_cookies ||= []) << Cookie.new(cookie, value)
+    else 
+      (@response_cookies ||= []) << cookie
+    end
+  end
+  alias_method :send_cookie, :add_cookie
+
+  # Return the output buffer.
+  
+  def body
+    @output_buffer
+  end
+
+end
+
+end

data/lib/raw/context/session.rb

@@ -0,0 +1,198 @@
+require "md5"
+
+require "facets/core/class/cattr"
+require "facets/more/synchash"
+require "facets/more/times"
+require "facets/more/expirable"
+require "facets/more/settings"
+
+require "raw/cgi/cookie"
+
+module Raw
+  
+# A web application session. 
+#
+# State is a neccessary evil but session variables
+# should be avoided as much as possible. Session state 
+# is typically distributed to many servers so avoid 
+# storing complete objects in session variables, only 
+# store oids and small integer/strings.
+# 
+# The session should be persistable to survive server 
+# shutdowns.
+#
+# The session can be considered as a Hash where key-value
+# pairs are stored. Typically symbols are used as keys. By
+# convention uppercase symbols are used for internal Nitro
+# session variables (ie :FLASH, :USER, etc). User applications
+# typically use lowercase symbols (ie :cart, :history, etc).
+#
+#--
+# TODO: rehash of the session cookie
+# TODO: store -> cache, reimplement helpers.
+#++
+
+class Session < Hash
+  include Expirable
+
+  # Session id salt.
+
+  setting :session_id_salt, :default => 'SALT', :doc => 'Session id salt'
+
+  # The name of the cookie that stores the session id.
+
+  setting :cookie_name, :default => 'nsid', :doc => 'The name of the cookie that stores the session id'
+
+  # useful with persistents sessions stores
+  
+  setting :cookie_expires, :default => false, :doc => 'Set expires parameter of session cookie equal to the keepalive setting?'
+
+  # The session keepalive time. The session is eligable for
+  # garbage collection after this time passes.
+  
+  setting :keepalive, :default => 30.minutes, :doc => 'The session keepalive time'
+
+  # The type of the session cache. The generalized caching 
+  # system in Glue is used. The following options are available:
+  #
+  # * :memory [default]
+  # * :drb
+  # * :og 
+  # * :file
+  # * :memcached
+
+  setting :cache_type, :default => :memory, :doc => 'The type of session cache'
+
+  # The address of the cache store.
+  
+  setting :cache_address, :default => '127.0.0.1', :doc => 'The address of the cache store'
+
+  # The port of the cache store.
+  
+  setting :cache_port, :default => 9069, :doc => 'The port of the cache store'
+
+  class << self
+
+    # The sessions cache (store). 
+
+    attr_accessor :cache
+    alias_method :store, :cache
+    
+    # Load the correct Session specialization according to the
+    # cache type.
+
+    def setup(type = Session.cache_type)
+      # gmosx: RDoc friendly. 
+      require "raw/context/session/" + type.to_s
+    end
+
+    # Lookup the session in the cache by using the session
+    # cookie value as a key. If the session does not exist
+    # creates a new session, inserts it in the cache and 
+    # appends a new session cookie in the response.
+    
+    def lookup(context)
+      if session_id = context.cookies[Session.cookie_name]
+        session = Session.cache[session_id]
+      end
+
+      unless session
+        # Create new session.
+        session = Session.new(context)
+        cookie = Cookie.new(Session.cookie_name, session.session_id)
+        if Session.cookie_expires
+          cookie.expires = Time.now + Session.keepalive 
+        end
+        context.add_cookie(cookie)
+        Session.cache[session.session_id] = session 
+      else
+        # Access ('touch') the existing session.
+        session.touch!
+      end
+      
+      return session
+    end
+
+    # The number of active (online) sessions.
+    # DON'T use yet!
+    
+    def count
+      Session.cache.size
+    end
+    
+    # Perform Session garbage collection. You may call this 
+    # method from a cron job.
+    
+    def garbage_collect
+      expired = []
+      for s in Session.cache.all
+        expired << s.session_id if s.expired?
+      end
+      for sid in expired
+        Session.cache.delete(sid)
+      end
+    end
+    alias_method :gc!, :garbage_collect
+  
+    # Returns the current session from the context thread local
+    # variable.
+    
+    def current
+      Context.current.session
+    end
+    
+  end
+
+  # The unique id of this session.
+
+  attr_reader :session_id
+
+  # Create the session for the given context.
+  # If the hook method 'created' is defined it is called
+  # at the end. Typically used to initialize the session
+  # hash.
+
+  def initialize(context = nil)
+    @session_id = create_id
+    expires_after(Session.keepalive)
+    created if respond_to?(:created)
+  end
+
+  # Synchronize the session store, by 
+  # restoring this session. Especially useful
+  # in distributed and/or multiprocess setups.
+  
+  def sync
+    Session.cache[@session_id] = self
+  end
+  alias_method :restore, :sync
+  
+  def touch!
+    expires_after(Session.keepalive)
+  end  
+  
+protected
+  
+  # Calculates a unique id.
+  #
+  # The session id must be unique, a monotonically 
+  # increasing function like time is appropriate. 
+  # Random may produce equal ids? add a prefix 
+  # (SALT) to stop hackers from creating session_ids.
+  #--
+  # THINK: Is MD5 slow??? Allow for pluggable hashes.
+  #++
+  
+  def create_id
+    now = Time.now
+    md5 = Digest::MD5.new
+    md5.update(now.to_s)
+    md5.update(now.usec.to_s)
+    md5.update(rand(0).to_s)
+    md5.update(Session.session_id_salt)
+    md5.hexdigest
+  end
+
+end
+
+end

data/lib/raw/context/session/drb.rb

@@ -0,0 +1,11 @@
+require "glue/cache/drb"
+
+require "raw/context/session"
+
+module Raw
+
+Logger.info "Using DRb sessions at #{Session.cache_address}:#{Session.cache_port}." if defined?(Logger) && $DBG
+
+Session.cache = Glue::DrbCache.new(Session.cache_address, Session.cache_port)
+
+end

data/lib/raw/context/session/file.rb

@@ -0,0 +1,15 @@
+require "glue/cache/file"
+
+require "raw/context/session"
+
+module Raw
+  
+# A Session manager that persists sessions on disk.
+
+Logger.info "Using File sessions." if defined?(Logger) && $DBG
+
+Session.cache = Glue::FileCache.new("session_#{Session.cookie_name}", Session.keepalive)
+
+end
+
+# * Guillaume Pierronnet <guillaume.pierronnet@gmail.com>

data/lib/raw/context/session/memcached.rb

@@ -0,0 +1,13 @@
+require "glue/cache/memcached"
+
+require "raw/context/session"
+
+module Raw
+  
+# A Session manager that persists sessions on disk.
+
+Logger.debug "Using MemCached sessions." if defined?(Logger) && $DBG
+
+Session.cache = Glue::MemCached.new("session_#{Session.cookie_name}", Session.keepalive)
+
+end

data/lib/raw/context/session/memory.rb

@@ -0,0 +1,12 @@
+require "glue/cache/memory"
+require "glue/logger"
+
+require "raw/context/session"
+
+module Raw
+
+Logger.info "Using Memory sessions." if defined?(Logger) && $DBG
+
+Session.cache = Glue::MemoryCache.new
+
+end

data/lib/raw/context/session/og.rb

@@ -0,0 +1,15 @@
+require "glue/cache/og"
+
+require "raw/context/session"
+
+module Raw
+
+# A Session manager that persists sessions on an Og store.
+
+Logger.debug "Using Og sessions." if defined?(Logger) && $DBG
+
+Session.cache = OgCache.new("session_#{Session.cookie_name}", Session.keepalive)
+
+end
+
+# * Guillaume Pierronnet <guillaume.pierronnet@gmail.com>

data/lib/raw/context/session/pstore.rb

@@ -0,0 +1,13 @@
+require "glue/cache/pstore"
+
+require "raw/context/session"
+
+module Raw
+  
+# A Session manager that is using PStore to store state
+
+Logger.info "Using PStore sessions." if defined?(Logger) && $DBG
+
+Session.cache = Glue::PStoreCache.new(Session.keepalive)
+
+end

data/lib/raw/control.rb

@@ -0,0 +1,18 @@
+require "raw/compiler/filter/elements/element"
+require "raw/helper/xhtml"
+
+module Raw
+
+# A specialized kind of element used for implementing UI 
+# controls.
+#--
+# TODO: add support for the singleton pattern to avoid excessive
+# memory usage.
+#++
+
+class Control < Element  
+  # THINK: maybe include this in element too?
+  include XhtmlHelper
+end
+
+end

data/lib/raw/control/attribute.rb

@@ -0,0 +1,91 @@
+require "raw/control"
+
+module Raw
+
+# The base class for controls used to inspect object 
+# attributes.
+#--
+# TODO: find a better name.
+#++
+
+class AttributeControl < Control
+
+  # The attribute that this control renders.
+  
+  attr_accessor :attribute
+
+  # The annotations used for rendering
+  
+  attr_accessor :anno
+      
+  # The value
+  
+  attr_accessor :value
+  alias_method :values, :value
+  
+  # === Input
+  #
+  # * object = the object to inspect
+  # * a = the attribute to inspect
+  # * options = additional options
+ 
+  def initialize(object, a, options)
+    @object = object
+    @attribute = a
+    @anno = @object.class.ann(@attribute)
+    @value = @object.send(@attribute)
+    @options = options
+  end
+  
+private
+
+  # Used as id attribute in HTML markup.
+  def control_id
+    "#{@attribute}_ctl"
+  end
+
+  # Emit the label for this control.
+  # The label is skipped if the control is created with the
+  # option :no_label set to true.
+  
+  def emit_label
+    return "" if @options[:no_label]
+    title = @anno[:title] || @options[:label] || @attribute.to_s.humanize
+    %{<label for="#{control_id}">#{title}</label>}
+  end
+    
+  # Emit the css style for this control.
+  # This mehtod takes into account the passed options (first) 
+  # and then the attribute annotations.
+  
+  def emit_style
+    unless style = (@options[:style] || @anno[:control_style])
+      if self.class.respond_to? :style
+        style = self.class.style
+      else
+        style = nil
+      end
+    end
+    style ? %{ style="#{style}"} : ''
+  end
+  
+  # Add support to your controls for being disabled
+  # by including an emit_disabled on form items
+  # or testing for is_disabled? on more complex controls.
+  
+  def emit_disabled
+    is_disabled? ? %{ disabled="disabled"} : ''
+  end
+  
+  #--
+  # FIXME
+  #++
+  
+  def is_disabled?
+    return false if @options[:all]
+    @options[:disable_controls] || @anno[:disable_control]
+  end
+
+end
+
+end