bijou 0.1.0

data/lib/bijou/filters.rb

@@ -0,0 +1,107 @@
+#
+# Copyright (c) 2007-2008 Todd Lucas. All rights reserved.
+#
+# filters.rb - Contains built-in filter definitions
+#
+require 'cgi'
+require 'bijou/common'
+
+module Bijou
+  #
+  # A filter may be used to modify text from an output tag prior to rendering. 
+  # For example, the output tag:
+  #
+  #   <%= user.first_name | h %>
+  #
+  # Will pipe the text returned from the first_name method through the +h+
+  # filter. The <tt>h</tt> filter represents Bijou::EncodeHTML and serves to
+  # escape the text for HTML presentation.
+  #
+  # Note that filters may be chained by listing them one after the other 
+  # following the pipe separator. For example, the following output tag and
+  # filter sequence:
+  #
+  #   <%= user.first_name | th %>
+  #
+  # first invokes the +t+ filter, which trims text using EncodeTrim, and then
+  # pipes the result of that to the +h+ filter, for final HTML  presentation.
+  #
+  class Filter
+    # Used during code generation to produce the code that will be used to 
+    # call the apply method.
+    def render(input)
+      "Bijou::Filter.apply(#{input})"
+    end
+
+    # The base filter is a no-op, returning the original string, unaltered.
+    def self.apply(input)
+      input # no-op
+    end
+  end
+
+  # The +h+ filter escapes the input for HTML presentation.
+  class EncodeHTML < Filter
+    def render(input)
+      "Bijou::EncodeHTML.apply(#{input})"
+    end
+
+    def self.apply(input)
+      ::CGI::escapeHTML(input)
+    end
+  end
+
+  # The +u+ filter escapes the input, replacing characters that are unsafe for
+  # passing as a URL parameter, with their escaped equivalents.
+  class EncodeURL < Filter
+    def render(input)
+      "Bijou::EncodeURL.apply(#{input})"
+    end
+
+    def self.apply(input)
+      ::CGI::escape(input)
+    end
+  end
+
+  # The +a+ filter escapes text intended for HTML tag attribute values.
+  class EncodeAttributeValue < Filter
+    def render(input)
+      "Bijou::EncodeAttribute.apply(#{input})"
+    end
+
+    def self.apply(input)
+      input.gsub(/&/n, '&amp;').gsub(/\"/n, '&quot;').gsub(/\'/n, '&apos;').gsub(/</n, '&lt;')
+    end
+  end
+
+  # Removes
+  class EncodeTrim < Filter
+    def render(input)
+      "Bijou::EncodeTrim.apply(#{input})"
+    end
+
+    def self.apply(input)
+      #s = input.dup
+      #s.sub!(/^\s*/, "")
+      #s.sub!(/\s*$/, "")
+      #s
+      input.strip
+    end
+  end
+
+  #--
+  # TODO: Move this into an installable filter.
+  #++
+  #
+  # This filter doesn't really do anything. It's a basic example of a filter
+  # that might take Wiki-ized text and display as HTML.
+  #
+  class EncodeWiki < Filter
+    def render(input)
+      "Bijou::EncodeWiki.apply(#{input})"
+    end
+
+    def self.apply(input)
+      input.gsub /\n/, "<br/>\n";
+    end
+  end
+end

data/lib/bijou/httprequest.rb

@@ -0,0 +1,108 @@
+#
+# Copyright (c) 2007-2008 Todd Lucas. All rights reserved.
+#
+# httprequest.rb - The base HttpRequest class
+#
+require 'bijou/common'
+
+module Bijou
+  #
+  # This class represents an incoming HTTP request, presenting a common
+  # interface to the Bijou component regardless of the server environment.
+  #
+  class HttpRequest
+    def initialize
+      @params = {}
+      @query_string = {}
+      @form = {}
+      @server_variables = {}
+      @cookies = {}
+      @http_method = ''
+    end
+
+    # Returns a hash containing items passed via the HTTP query string.
+    # Synonym for #get.
+    attr_reader :query_string
+
+    # Returns a hash containing form data passed via the HTTP POST action.
+    # Synonym for #post.
+    attr_reader :form
+
+    # Returns a hash containing the combined values of the query string,
+    # post data, and cookies.
+    attr_reader :params
+
+    #
+    # A hash containing standard CGI environment variables.
+    #
+    #   AUTH_TYPE               HTTP_HOST          REMOTE_IDENT
+    #   CONTENT_LENGTH          HTTP_NEGOTIATE     REMOTE_USER
+    #   CONTENT_TYPE            HTTP_PRAGMA        REQUEST_METHOD
+    #   GATEWAY_INTERFACE       HTTP_REFERER       SCRIPT_NAME
+    #   HTTP_ACCEPT             HTTP_USER_AGENT    SERVER_NAME
+    #   HTTP_ACCEPT_CHARSET     PATH_INFO          SERVER_PORT
+    #   HTTP_ACCEPT_ENCODING    PATH_TRANSLATED    SERVER_PROTOCOL
+    #   HTTP_ACCEPT_LANGUAGE    QUERY_STRING       SERVER_SOFTWARE
+    #   HTTP_CACHE_CONTROL      REMOTE_ADDR
+    #   HTTP_FROM               REMOTE_HOST
+    #
+    # As well as additions that aren't present in cgi.rb.
+    #
+    #   REQUEST_URI
+    #
+    attr_reader :server_variables
+
+    # A hash containing cookies sent by the client.
+    attr_reader :cookies
+
+    # A string representing the HTTP request method (e.g., GET, POST, or HEAD).
+    attr_reader :http_method
+
+    # Returns a hash containing items passed via the HTTP query string.
+    # Synonym for #query_string.
+    def get
+      @query_string
+    end
+
+    # Returns a hash containing form data passed via the HTTP POST action.
+    # Synonym for #form.
+    def post
+      @form
+    end
+
+    # TODO: These should be moved to CGI::Request
+    def referrer
+      @server_variables['HTTP_REFERER']
+    end
+
+    def referer
+      @server_variables['HTTP_REFERER']
+    end
+
+    #--
+    # ASP.NET has:
+    # path, path_info, url
+    # which don't directly correspond to Apache CGI variables.
+#    def url
+#      @server_variables['REQUEST_URI']
+#    end
+    #++
+
+    def virtual_path
+#      @server_variables['REQUEST_URI']
+      @server_variables['PATH_INFO']
+    end
+
+    def physical_path
+      @server_variables['PATH_TRANSLATED']
+    end
+
+    def request_method
+      @server_variables['REQUEST_METHOD']
+    end
+
+    def user_agent
+      @server_variables['HTTP_USER_AGENT']
+    end
+  end
+end

data/lib/bijou/httpresponse.rb

@@ -0,0 +1,268 @@
+#
+# Copyright (c) 2007-2008 Todd Lucas. All rights reserved.
+#
+# httpresponse.rb - The base HttpResponse class
+#
+require 'cgi' # for encoding functions
+require 'bijou/common'
+
+module Bijou
+  class HttpResponse
+    ContentType = 'Content-Type'
+    SetCookie = 'Set-Cookie'
+    Location = 'Location'
+    DefaultContentType = 'text/html'
+    DefaultCharset = 'iso-8859-1'
+
+    CR  = "\015"
+    LF  = "\012"
+    EOL = CR + LF
+
+    attr_accessor :buffer_output
+
+    # Some environments generate their own headers. Headers should be 
+    # suppressed in such cases. Note, however that response header attributes,
+    # such as content_type, will have no effect.
+    attr_accessor :suppress_headers
+
+    # A flag indicating whether to suppress content rendering to the client.
+    attr_accessor :suppress_content
+
+    attr_accessor :status
+
+    def initialize
+      @buffer_output = true
+      @content_type = DefaultContentType
+      @charset = DefaultCharset
+      @headers = {}
+      @error_headers = {}
+      @cookies = []
+      @output = ''
+      @log = ''
+      @suppress_headers = false
+      @suppress_content = false
+
+      @status = 200
+      update_content_type_header
+    end
+
+    @@status_map = {
+      200 => "200 OK",
+      206 => "206 Partial Content",
+      300 => "300 Multiple Choices",
+      301 => "301 Moved Permanently",
+      302 => "302 Found",
+      304 => "304 Not Modified",
+      400 => "400 Bad Request",
+      401 => "401 Authorization Required",
+      403 => "403 Forbidden",
+      404 => "404 Not Found",
+      405 => "405 Method Not Allowed",
+      406 => "406 Not Acceptable",
+      411 => "411 Length Required",
+      412 => "412 Precondition Failed",
+      500 => "500 Internal Server Error",
+      501 => "501 Method Not Implemented",
+      502 => "502 Bad Gateway",
+      506 => "506 Variant Also Negotiates",
+    }
+
+    def clear_headers
+      @headers = {}
+      @content_type = nil
+      @charset = nil
+    end
+
+    def clear_content
+      @output = ''
+    end
+
+    def clear
+      clear_headers
+      clear_content
+    end
+
+    # Sets the HTTP MIME type of the response. The default 
+    # is <tt>"text/html"</tt>
+    def content_type=(str)
+      @content_type = str
+      update_content_type_header
+    end
+
+    # Gets the HTTP MIME type of the response. The default 
+    # is <tt>"text/html"</tt>
+    def content_type
+      @content_type
+    end
+
+    def charset=(str)
+      @charset = str
+      update_content_type_header
+    end
+
+    def charset
+      @charset
+    end
+
+    def append_cookie(cookie)
+      @cookies.push(cookie)
+    end
+
+    # Sets the value of the specified header. Case is significant so, for
+    # example +Content-type+ is not valid, whereas +Content-Type+ is valid.
+    def set_header(header, value)
+      if header.downcase == ContentType.downcase
+        set_header_content_type(value)
+      elsif header.downcase == Location.downcase
+        @error_headers[header] = value
+      elsif header.downcase == SetCookie.downcase
+        # We include cookies for 302 Found (redirect)
+        @error_headers[header] = value
+      end
+      @headers[header] = value
+    end
+
+    # Returns the specified header value. Case is significant so, for
+    # example +Content-type+ is not valid, whereas +Content-Type+ is valid.
+    def get_header(header)
+      @headers[header]
+    end
+
+    # Removes a header having the specified name. Case is significant.
+    def clear_header(header)
+      if header.downcase == ContentType.downcase
+        @content_type = nil
+      end
+      @headers.delete(header)
+    end
+
+    def render_headers
+      result = '';
+
+      if @@status_map.has_key? @status
+        status = @@status_map[@status]
+      else
+        status = @@status_map[200]
+      end
+
+      # status line, e.g.: "Status: 200 OK\r\n"
+      result = "Status: " + status + EOL
+
+      if @status < 300
+        headers = @headers
+      else
+        headers = @error_headers
+      end
+
+      headers.each { |key,value|
+        if value && !value.empty?
+          #result << "#{key}: #{value}" + EOL
+          result << "#{key}: #{value}\n"
+        end
+      }
+      if @cookies
+        @cookies.each {|cookie|
+          result << "Set-Cookie: " + cookie.to_s + EOL
+        }
+      end
+
+      # BUGBUG: The output contains \n and after print stdio translates to
+      # \r\n, which increases length. We can't use content-length until fixed.
+      #result << "Content-Length: #{@output.length}\n"
+
+      result << EOL
+      
+      #print "Content-type: text/plain; charset=iso-8859-1\n\n"
+      result
+    end
+
+    # Called to terminate a request before the render cycle is complete.
+    # This is useful for redirecting from init or render handlers, for example.
+    def end_request
+      raise EndRequest
+    end
+
+    def location(value)
+      set_header("Location", value)
+    end
+
+    def redirect(value, status = 302)
+      @status = status
+      @suppress_content = true
+      location(value)
+      end_request
+    end
+
+    def render
+      result = ''
+      result << render_headers unless @suppress_headers
+      result << @output
+      result
+    end
+
+    def url_encode(string)
+      ::CGI::escape(string)
+    end
+
+    def html_encode(string)
+      ::CGI::escapeHTML(string)
+    end
+
+    def write(str)
+      @output << str
+    end
+
+    def writeline(str)
+      @output << str + "\n"
+    end
+
+    def log(text)
+      @log << text
+    end
+
+    def get_log
+      @log
+    end
+
+  private
+
+    def update_content_type_header
+      if @content_type && !@content_type.empty?
+        if @charset && !@charset.empty?
+          @headers[ContentType] = "#{@content_type}; charset=#{@charset}"
+        else
+          @headers[ContentType] = @content_type
+        end
+      else
+        @headers.delete(ContentType)
+      end
+    end
+
+    # If the caller manually sets the content type via the headers hash, then
+    # we make an effort to set the two special content type attributes from it.
+    def set_header_content_type(value)
+      @content_type = nil
+      @charset = nil
+
+      if value && !value.empty?
+        ct = value.split(/\s*;\s*/)
+        if ct.length > 0
+          # Look for Content-Type
+          if ct[0] =~ /^\s*([^\s]+)\s*$/
+            @content_type = $1
+          end
+
+          ct.shift
+
+          # Look for charset
+          ct.each { |param|
+            if param =~ /^\s*charset\s*=\s*(.+?)\s*$/
+              @charset = $1
+            end
+          }
+        end
+      end
+    end
+
+  end
+end