raw 0.49.0

data/lib/raw/context/flash.rb

@@ -0,0 +1,157 @@
+require "nitro/aspects"
+
+module Raw
+
+  # This module adds flashing support to the Controllers. 
+  
+  module Flashing
+  
+    def self.included(base)
+      super
+      base.before(:call => :init_flash)
+      base.after(:call => :clean_flash)
+    end
+    
+    # A Flash is a special hash object that lives in the session. 
+    # The values stored in the Flash are typically maintained 
+    # for the duration of one request. After the request is over,
+    # the Hash is cleared.
+    # 
+    # You may want to use the Flash to pass error messages or 
+    # other short lived objects.
+    #
+    # Use capitalized keys to denote system variables. Reserve
+    # lower case keys for user application variables.
+        
+    class Flash < Hash
+    
+      def initialize
+        super
+        @dirty = {}
+      end
+    
+      def []=(key, val)
+        super
+        keep(key)
+      end
+
+      # Keep the specific key or the whole Flash.
+            
+      def keep(key = nil)
+        set_dirty(key, false)
+      end
+      
+      # Discard the specific key or the whole Flash.
+      
+      def discard(key = nil)
+        set_dirty(key)
+      end      
+      
+      def clean # :nodoc:
+        keys.each do |k|
+          unless @dirty[k]
+            set_dirty(k)
+          else
+            delete(k)
+            @dirty.delete(k)
+          end
+        end
+        
+        # remove externaly updated keys.
+        
+        (@dirty.keys - keys).each { |k| @dirty.delete k } 
+      end
+
+      # :section: Helpers
+      
+      # Push a value in an array flash variable.
+      #
+      # === Example
+      #
+      # flash.push :ERRORS, 'This is the first error'
+      # flash.push :ERRORS, 'This is the second error'
+      #
+      # flash[:ERRORS] # => []
+      
+      def push(key, *values)
+        val = self[key]
+        val ||= []
+        if values.size == 1
+          val << values[0]
+        else
+          val << values
+        end
+        self[key] = val
+      end
+      
+      # Pop a value from an array flash variable.
+      
+      def pop(key)
+        if arr = self[key]
+          if arr.is_a? Array
+            return arr.pop
+          else
+            return arr
+          end
+        end
+        return nil
+      end
+
+      # Another helper, concats a whole array to the given flash
+      # key.
+      
+      def concat(key, arr)
+        for val in arr.to_a
+          push key, val
+        end
+      end      
+
+      # Join helper
+      
+      def join(key, sep = ', ')
+        value = self[key]
+        
+        if value.is_a? Array
+          return value.join(sep)
+        else
+          return value
+        end
+      end
+            
+    private
+      
+      def set_dirty(key = nil, flag = true)
+        if key
+          @dirty[key] = flag
+        else
+          keys.each { |k| @dirty[k] = flag }
+        end      
+      end
+      
+    end
+
+  private
+
+    def flash
+      session[:FLASH] ||= Flash.new
+    end
+        
+    # Some useful aspects.
+      
+    # Marks flash entries as used and expose the flash to the 
+    # view.
+    
+    def init_flash
+      flash.discard
+    end
+
+    # Deletes the flash entries that were not marked for 
+    # keeping.
+    
+    def clean_flash
+      flash.clean
+    end
+
+  end  
+
+end

data/lib/raw/context/global.rb

@@ -0,0 +1,88 @@
+# Global scoped variables. This is backed by a Cache store.
+#--
+# TODO: implement as a refactoring of session?
+#++
+
+class Global
+
+  # The type of the global 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 global cache'
+
+  # The address of the store.
+  
+  setting :cache_address, :default => '127.0.0.1', :doc => 'The address of the global cache'
+
+  # The port of the store.
+  
+  setting :cache_port, :default => 9079, :doc => 'The port of the global cache'
+  
+  class << self
+    # The global cache (store). 
+
+    attr_accessor :cache
+  
+    # Init the correct Global cache.
+    
+    def setup(type = Global.cache_type)
+      return if Global.cache
+
+      case type
+        when :memory
+          require 'glue/cache/memory'
+          Global.cache = Glue::MemoryCache.new
+
+        when :drb
+          require 'glue/cache/drb'
+          Global.cache = DrbCache.new(Global.cache_address, Global.cache_port)          
+      end
+    end    
+  
+    # Initialize a global value once.
+    
+    def init(key, value)
+      unless Global[key]
+        Global[key] = value
+      end
+    end
+    
+    def set(key, value)
+      Global.cache[key] = value
+    end
+    alias_method :[]=, :set
+    
+    def get(key)
+      return Global.cache[key]
+    end
+    alias_method :[], :get
+
+    # If block is given it acts as an update methods,
+    # that transparently handles distributed stores.
+    #
+    # Global.update(:USERS) do |users|
+    #   users << 'gmosx'
+    # end
+        
+    def update(key)
+      if block_given?
+        # update, also handles distributed stores.
+        val = Global.cache[key]
+        yield val
+        Global.cache[key] = val
+      end    
+    end
+    
+    def delete(key)
+      Global.cache.delete(key)
+    end
+
+  end
+  
+end

data/lib/raw/context/request.rb

@@ -0,0 +1,338 @@
+module Raw
+  
+# Encapsulates a request. This is an abstract request
+# typically extended by sub-classes. This module
+# is included in Context.
+
+module Request
+
+  # The request input stream.
+
+  attr_accessor :in
+
+  # The request headers collection. Also called
+  # the request environment (env).
+
+  attr_accessor :headers
+  alias_method :env, :headers
+  alias_method :env=, :headers=
+  alias_method :env_table, :headers
+
+  attr_accessor :post_params
+  attr_accessor :get_params
+
+  # The parsed query parameters collection.
+
+  def params
+	  if method == :post
+		  @post_params
+	  else
+		  @get_params
+	  end
+  end
+
+  def params=(pa)
+	  if method == :post
+		  @post_params = pa
+	  else
+		  @get_params = pa
+	  end
+  end
+
+  alias_method :query, :params
+  alias_method :parameters, :params
+  
+  # The request cookies.
+
+  attr_accessor :cookies
+  alias_method :cookie, :cookies
+
+  # The request protocol.
+
+  def protocol
+    @headers['HTTPS'] == "on" ? "https://" : "http://"
+  end
+
+  # Is this an ssl request?
+
+  def ssl?
+    @headers["HTTPS"] == "on"
+  end
+
+  # The request uri.
+
+  def uri
+    @headers["REQUEST_URI"]
+  end
+
+  # The path info. Typically this is the rewritten uri without
+  # the query string.
+  
+  def path_info
+    @headers["PATH_INFO"]
+  end
+  alias_method :path, :path_info
+
+  # Returns the domain part of a host.
+  #
+  # === Examples
+  #
+  # www.nitroproject.org: request.domain # => 'nitroproject.org'
+  # www.nitroproject.co.uk: request.domain(2) # => 'nitroproject.co.uk'
+  
+  def domain tld_length = 1
+    host.split('.').last(1 + tld_length).join('.')
+  end
+
+  # Returns all the subdomains as an array.
+  #
+  # === Examples
+  # 
+  # my.name.nitroproject.org: request.subdomains # => ['my', 'name']
+  
+  def subdomains tld_length = 1 
+    parts = host.split('.')
+    parts[0..-(tld_length+2)]
+  end
+
+  # The request query string.
+
+  def query_string 
+    headers["QUERY_STRING"]
+  end
+  
+  # The request method. Alternatively you could use the 
+  # request method predicates.
+  #
+  # === Examples
+  #
+  # if request.method == :get
+  # if request.get?
+
+  def method
+    @headers["REQUEST_METHOD"].downcase.to_sym
+  end
+
+  #--
+  # Define a set of helpers to determine the request
+  # method (get?, post?, put?, delete?, head?)
+  #++
+  
+  for m in [:get, :post, :put, :delete, :head]
+    eval %{
+      def #{m}?; method == :#{m}; end
+    }
+  end
+
+  # Determine whether the body of a POST request is URL-encoded 
+  # (default), XML, or YAML by checking the Content-Type HTTP 
+  # header:
+  #
+  #   Content-Type        Post Format
+  #   application/xml     :xml
+  #   text/xml            :xml
+  #   application/x-yaml  :yaml
+  #   text/x-yaml         :yaml
+  #   *                   :url_encoded
+  
+  def post_format
+    @post_format ||= if @headers['HTTP_X_POST_DATA_FORMAT']
+      @headers['HTTP_X_POST_DATA_FORMAT'].downcase.to_sym
+    else
+      case @headers['CONTENT_TYPE'].to_s.downcase
+      when 'application/xml', 'text/xml' then :xml
+      when 'application/x-yaml', 'text/x-yaml' then :yaml
+      else :url_encoded
+      end
+    end
+  end
+
+  # Is this a POST request formatted as XML or YAML?
+  
+  def formatted_post?
+    post? && (post_format == :xml || post_format == :yaml)
+  end
+
+  # Is this a POST request formatted as XML?
+  
+  def xml_post?
+    post? && post_format == :xml
+  end
+
+  # Is this a POST request formatted as YAML?
+  
+  def yaml_post?
+    post? && post_format == :yaml
+  end
+
+  # Is this an XhtmlRpcRequest?
+  # Returns true if the request's 'X-Requested-With' header 
+  # contains 'XMLHttpRequest'. Compatible with the Prototype 
+  # Javascript library.
+  
+  def xml_http_request?
+    not /XMLHttpRequest/i.match(@headers['HTTP_X_REQUESTED_WITH']).nil?
+  end
+  alias_method :xhr?, :xml_http_request?
+  alias_method :script?, :xml_http_request?
+    
+  # Return the referer. For the initial page in the
+  # clickstream there is no referer, set "/" by default.
+    
+  def referer
+    @headers["HTTP_REFERER"] || "/"
+  end
+  alias_method :referrer, :referer
+
+  # The content_length
+  
+  def content_length
+    @headers["CONTENT_LENGTH"].to_i
+  end
+
+  # The remote IP address. REMOTE_ADDR is the standard
+  # but will fail if the user is behind a proxy.  
+  # HTTP_CLIENT_IP and/or HTTP_X_FORWARDED_FOR are set by 
+  # proxies so check for these before falling back to 
+  # REMOTE_ADDR. HTTP_X_FORWARDED_FOR may be a comma-delimited 
+  # list in the case of multiple chained proxies; the first 
+  # is the originating IP.
+                          
+  def remote_ip
+    return @headers['HTTP_CLIENT_IP'] if @headers.include?('HTTP_CLIENT_IP')
+
+    if @headers.include?('HTTP_X_FORWARDED_FOR') then
+      remote_ips = @headers['HTTP_X_FORWARDED_FOR'].split(',').reject do |ip|
+        ip =~ /^unknown$/i or local_net?(ip)
+      end
+
+      return remote_ips.first.strip unless remote_ips.empty?
+    end
+
+    return @headers['REMOTE_ADDR']
+  end
+
+  # Request is from a local network? (RFC1918 + localhost)
+  
+  def local_net?(ip = remote_ip)
+    bip = ip.split('.').map{ |x| x.to_i }.pack('C4').unpack('N')[0]
+
+    # 127.0.0.1/32    => 2130706433
+    # 192.168.0.0/16  => 49320
+    # 172.16.0.0/12   => 2753
+    # 10.0.0.0/8      => 10
+
+    { 0 => 2130706433, 16 => 49320, 20 => 2753, 24 => 10}.each do |s,c|
+       return true if (bip >> s) == c
+    end
+    
+    return false
+  end
+  
+  # Request comming from local?
+  
+  def local?(ip = remote_ip)
+    # TODO: should check if requesting machine is the one the server is running
+    return true if ip == '127.0.0.1'
+  end
+
+  # The server port.
+
+  def port
+    @headers['SERVER_PORT'].to_i
+  end
+
+  # The server host name.
+  # Also handles proxy forwarding.
+
+  def host
+    @headers['HTTP_X_FORWARDED_HOST'] || @headers['HTTP_HOST'] 
+  end
+
+  # The host uri.
+  
+  def host_uri
+    "#{protocol}#{host}"
+  end
+  alias_method :server_uri, :host_uri
+  # This is deprecated.
+  alias_method :host_url, :host_uri
+
+  # Different servers hold user agent in differnet 
+  # strings (unify this).
+  
+  def user_agent
+    headers["HTTP_USER_AGENT"] || headers["USER-AGENT"]
+  end
+
+  # The raw data of the request.
+  # Useful to implement Webservices.
+  #--
+  # FIXME: better name and implementation.
+  #++
+
+  def raw_body
+    unless @raw_body
+      @in.rewind
+      @raw_body = @in.read(content_length)
+    end
+
+    @raw_body
+  end
+  
+  # Lookup a query parameter.
+  #--
+  # TODO: Check if unescape is needed.
+  #++
+  
+  def [](param)
+    params[param]
+  end
+
+  # Set a query parameter.
+
+  def []=(param, value)
+    params[param] = value
+  end
+  
+  # Check if a boolean param (checkbox) is true.
+  
+  def true?(param)
+    params[param] == 'on'
+  end
+  alias_method :enabled?, :true?
+  alias_method :boolean, :true?
+  
+  # Check if a boolean param (checkbox) is false.
+   
+  def false?(param)
+    !true?(param)
+  end
+  
+  # Fetch a parameter with default value.
+  
+  def fetch param, default = nil
+    params.fetch(param, default)
+  end
+  
+  # Check if a param is available.
+  #--
+  # gmosx: use instead of nil test to be more robust.
+  # (nil can be a hash element !)
+  #++
+    
+  def has_key?(key)
+    params.keys.include?(key)
+  end
+  alias_method :has_param?, :has_key?
+  alias_method :param?, :has_key?
+  alias_method :has?, :has_key?
+  alias_method :is?, :has_key?
+  
+  def keys
+    params.keys
+  end
+  
+end
+
+end