raw 0.49.0

data/lib/raw/cgi/cookie.rb

@@ -0,0 +1,47 @@
+module Raw
+
+# Encapsulates a HTTP Cookie.
+
+class Cookie
+  attr_reader :name
+  attr_accessor :value, :version
+  attr_accessor :domain, :path, :secure
+  attr_accessor :comment, :max_age
+
+ def initialize(name = nil, value = nil, expires = nil)
+    @name = name
+    @value = value
+    self.expires = expires
+    @version = 0    # Netscape Cookie THINK: maybe should make this 1 ??
+    @path = "/"     # gmosx: KEEP this!
+    @domain = @secure = @comment = @max_age = nil
+    @discard = @port = nil
+  end
+
+  # Set the cookie expiration.
+  
+  def expires=(t)
+    @expires = t && (t.is_a?(Time) ? t.httpdate : t.to_s)
+  end
+
+  # When the cookie expires.
+  
+  def expires
+    @expires && Time.parse(@expires)
+  end
+  
+  def to_s
+    str = "#{@name}=#{@value}"
+    str << "; Version=#{@version}" if @version > 0
+    str << "; Domain=#{@domain}" if @domain
+    str << "; Expires=#{@expires}" if @expires
+    str << "; Max-Age=#{@max_age}" if @max_age
+    str << "; Comment=#{@comment}" if @comment
+    str << "; Path=#{@path}" if @path
+    str << "; Secure" if @secure
+    return str
+  end
+
+end
+
+end

data/lib/raw/cgi/http.rb

@@ -0,0 +1,62 @@
+module Raw
+
+# Various HTTP related constants and utilities.
+
+module Http
+  
+  # HTTP protocol EOL constants.
+
+  CR = "\x0d"
+  LF = "\x0a"
+  CRLF = "\x0d\x0a"
+  EOL = CRLF
+
+  # Constants for readable code.
+
+  STATUS_OK = 200
+  STATUS_PARTIAL_CONTENT = 206
+  STATUS_MOVED = 301
+  STATUS_REDIRECT = 302
+  STATUS_SEE_OTHER = 303        
+  STATUS_SEE_OTHER_307 = 307    
+  STATUS_NOT_MODIFIED = 304
+  STATUS_BAD_REQUEST = 400
+  STATUS_AUTH_REQUIRED = 401       
+  STATUS_FORBIDDEN = 403           
+  STATUS_NOT_FOUND = 404           
+  STATUS_METHOD_NOT_ALLOWED = 405  
+  STATUS_NOT_ACCEPTABLE = 406      
+  STATUS_LENGTH_REQUIRED = 411     
+  STATUS_PRECONDITION_FAILED = 412 
+  STATUS_SERVER_ERROR = 500        
+  STATUS_NOT_IMPLEMENTED = 501    
+  STATUS_BAD_GATEWAY = 502         
+  STATUS_VARIANT_ALSO_VARIES = 506 
+
+  # Hash to allow id to description maping.
+
+  STATUS_STRINGS = {
+    200 => "OK",
+    206 => "Partial Content",
+    300 => "Multiple Choices",
+    301 => "Moved Permanently",
+    302 => "Found",
+    303 => "See other", # gmosx: VERIFY THIS
+    304 => "Not Modified",
+    307 => "See other 07", # gmosx: VERIFY THIS
+    400 => "Bad Request",
+    401 => "Authorization Required",
+    403 => "Forbidden",
+    404 => "Not Found",
+    405 => "Method Not Allowed",
+    406 => "Not Acceptable",
+    411 => "Length Required",
+    412 => "Precondition Failed",
+    500 => "Internal Server Error",
+    501 => "Method Not Implemented",
+    502 => "Bad Gateway",
+    506 => "Variant Also Negotiates"
+  }
+end
+  
+end

data/lib/raw/compiler.rb

@@ -0,0 +1,138 @@
+require "raw/compiler/reloader"
+
+module Raw
+
+# The Compiler dynamically generates action methods for the
+# Controllers.
+
+class Compiler
+
+  # A collection of the loaded template files.
+  
+  attr_accessor :templates
+
+  # The reloader monitors and reloads code and template files.
+  
+  attr_accessor :reloader
+
+  # Initialize the compiler.
+  
+  def initialize(application)
+    @application = application
+    @reloader = Reloader.new(application)
+    @templates = []
+  end
+
+  # This method compiles missing Controller methods. Only handles
+  # xxx___super and xxx___{format}___view methods.
+  
+  def compile(controller, meth)
+    meth = meth.to_s
+
+    if meth =~ %r{___super$}
+      compile_super(controller, meth)
+    elsif meth =~ %r{___view$}
+      compile_view(controller, meth)
+    else
+      return false
+    end
+  end
+
+  # Compile the action super-method for the given URI. This
+  # super-method calls the action and view sub-methods. The
+  # action sub-method is typically provided by the controller.
+  #
+  # In a sense, the super-method orchestrates the action and 
+  # view sub-methods to handle the given URI.
+
+  def compile_super(controller, meth)
+    action = meth.gsub(%r{___super$}, "")
+
+    Logger.debug "Compiling '#{action}' super-method" if $DBG        
+
+    if controller.action_or_template?(action, Context.current.format)
+      
+      # This is the actual control super method that calls
+      # the action code and the template for this format.
+      
+      code = lambda do |params|
+        @context.format.before_action(self, @context)
+
+        @action = action.to_sym 
+
+        # Call the action sub-method.
+
+        send(action, *params) if respond_to? action
+        
+        # Call the view sub-method (render the template).
+        
+        send("#{action}___#{@context.format}___view")
+
+        @context.format.after_action(self, @context)
+        
+        cache_output()        
+      end # lambda
+      
+      controller.send(:define_method, meth, code)
+      controller.send(:private, meth)
+      
+      return true
+    else
+      return false
+    end
+  end
+  
+  # Compile the view sub-method for the given URI. 
+  #--
+  # The sub-method is always generated, if no template is found
+  # it is just a nop method.
+  #
+  # TODO: cache the generated files (reuse the  cached files
+  # to extract error regions)
+  #++  
+  
+  def compile_view(controller, meth)
+    md = meth.match(%r{(.*)___(.*)___view})
+    action, format = md[1], md[2]
+
+    format = @application.dispatcher.formats[format]
+
+    Logger.debug "Compiling '#{action}' view sub-method [format: #{format}]" if $DBG        
+
+    unless controller.instance_methods.include? meth
+      # The view method is missing. The Compiler will try to 
+      # use a template or generate an empty view method.
+      
+      template = nil
+      
+      if path = controller.template_path(action, format)
+        # Keep a ref of this template for the reloader.
+        
+        @templates = @templates.push(path).uniq
+        
+        # Read the template source.
+                
+        template = File.read(path)
+
+        # Apply the template filters.
+        
+        unless template.blank? 
+          template = format.filter_template(template)
+        end
+      end
+
+      controller.class_eval <<-EOCODE # , path, 0 
+        def #{meth}
+          #{template}
+        end
+      EOCODE
+      
+      controller.send(:private, meth)
+    end
+        
+    return true
+  end
+
+end
+
+end

data/lib/raw/compiler/filter/cleanup.rb

@@ -0,0 +1,21 @@
+module Raw
+
+# Cleanup the xhtml code generated by REXML used in other 
+# filters.
+
+class CleanupFilter
+  
+  def apply(source)
+    source = source.dup
+
+    elements = "input|img|br|hr|link|style|render|include|inject|base|meta"
+    source.gsub! /<textarea ([^>]*)><\/textarea>/, '<textarea \1>#{}</textarea>'
+    source.gsub! /<(#{elements}) ([^>]*)><\/\1>/, '<\1 \2 />'
+    source.gsub! /<(#{elements})><\/\1>/, '<\1 />'
+
+    return source
+  end
+  
+end
+
+end

data/lib/raw/compiler/filter/elements.rb

@@ -0,0 +1,166 @@
+require "rexml/document"
+require "rexml/streamlistener"
+
+require "facets/core/kernel/constant"
+
+require "raw/compiler/filter/elements/element"
+
+module Raw
+
+# A filter that transforms user defined Elements. Elements
+# are custom tags that are used as macros or to implement
+# skins. 
+# 
+# === Example
+#
+# <Page>
+#   the 
+# </Page>
+
+class ElementsFilter
+
+  class Listener # :nodoc: all
+    include REXML::StreamListener
+
+    PREFIX_RE = /^#{Element.prefix}:/
+    CAPITALIZED_RE = /^[A-Z]/
+        
+    attr_accessor :buffer
+    
+    def initialize
+      super()
+      @buffer = ''
+      @stack = []
+    end
+    
+    def tag_start(name, attributes)    
+      if klass = is_element?(name)
+        obj = klass.new
+         
+        attributes.each do | k, v | 
+          obj.instance_variable_set("@#{k}", v)
+        end        
+          
+        @stack.push [obj, @buffer, @parent]
+          
+        @buffer = obj._text
+        @parent.add_child(obj) if @parent
+          
+        @parent = obj
+      else # This is a static element.
+        attrs = []
+        
+        attributes.each do | k, v | 
+          attrs << %|#{k}="#{v}"|
+        end
+        
+        attrs = attrs.empty? ? nil : " #{attrs.join(' ')}"
+        
+        @buffer << "<#{name}#{attrs}>"
+      end
+    end
+
+    def tag_end(name)    
+      if is_element? name
+        obj, @buffer, @parent = @stack.pop
+        @buffer << obj.render
+      else
+        @buffer << "</#{name}>"
+      end
+    end
+
+    # Check if a tag is an Element. If found, it also tries to 
+    # auto-extend the klass. Returns the Element class if found.
+    #
+    # Tries many classes in the following order:
+    #
+    # * Controller::XXX
+    # * {controller.ann(:self, :element_namespace)}::XXX
+    # * Nitro::Element::XXX
+    
+    def is_element?(name)
+      controller = Controller.current
+      
+      return false unless name =~ PREFIX_RE or name =~ CAPITALIZED_RE
+
+      name = name.gsub(PREFIX_RE,'').camelize if name =~ PREFIX_RE
+
+      # Try to use Controller::xxx
+      # gmosx, THINK: this looks a bit dangerous to me!
+      
+      begin
+        # gmosx, FIXME: Class.by_name also returns top level
+        # classes, how can we fix this?
+
+        klass = constant("#{controller}::#{name}")
+      rescue
+        # drink it!
+      end
+
+      # Try to use the Controller's :element_namespace annotation
+
+      if namespace = controller.ann(:self, :element_namespace)
+        begin
+          klass = constant("#{namespace}::#{name}")
+        rescue
+          # drink it!
+        end
+      end unless klass
+
+      # Try to use Nitro::Element::xxx then ::xxx
+      
+      begin
+        klass = constant("Nitro::Element::#{name}")
+      rescue
+        # drink it!
+      end unless klass
+
+      return false unless klass.kind_of? Class
+
+      # Try to auto-extend.
+
+      unless klass.ancestor? Element
+        if Element.auto_extend
+          klass.send(:include, ElementMixin)
+        else
+          return false
+        end
+      end
+
+      return klass
+    end
+    
+    def text(str)
+      @buffer << str
+    end
+    
+    def instruction(name, attributes)
+      @buffer << "<?#{name}#{attributes}?>"
+    end
+
+    def cdata(content)
+      @buffer << "<![CDATA[#{content}]]>"
+    end
+
+    def comment(c)
+      unless Template.strip_xml_comments
+        @buffer << "<!--#{c}-->"
+      end
+    end
+    
+    def doctype(name, pub_sys, long_name, uri)   
+      @buffer << "<!DOCTYPE #{name} #{pub_sys} #{long_name} #{uri}>\n"
+    end
+  end # Listener
+
+  # Apply the filter.
+  
+  def apply(source)
+    listen = Listener.new
+    REXML::Document.parse_stream(source, listen)
+    return listen.buffer
+  end
+
+end
+
+end

data/lib/raw/compiler/filter/elements/element.rb

@@ -0,0 +1,210 @@
+require "facets/core/string/demodulize"
+require "facets/core/string/capitalized"
+require "facets/core/string/camelize"
+require "facets/core/class/method_name"
+require "facets/core/dir/self/recurse"
+require "facets/more/settings"
+
+module Raw
+
+# A programmatically generated element. Elements are a form
+# of macros to allow for cleaner templates. They are evaluated
+# at compile time, so there is no performance hit when you use
+# them (at the expense of slightly reduced functionality).
+#
+# Nitro provides an additional method of defining elements.
+# Instead of creating a lot of small classes, you can put
+# .htmlx templates in the Element template_root. These templates
+# are automatically converted into Element classes.
+#
+# For extra safety, you are advised to place your classes in the
+# Nitro::Element namespace. If your classes do not extend
+# Nitro::Element, the Nitro::ElementMixin is automatically
+# injected in the class.
+#
+# An element can have and access a hierarchy of sub-elements.
+# use #{content :sub_element_name} to access the render output
+# of the subelement. Additionaly you can access the whole 
+# subelement object: _children[:sub_element_name]
+# 
+# === Design
+#
+# An underscore is used for the standard attibutes to avoid name 
+# clashes.
+
+module ElementMixin
+  # The parent of this element.
+  
+  attr_accessor :_parent
+  
+  # The children of this element.
+  
+  attr_accessor :_children
+  alias_method :children, :_children
+    
+  # The text of this element.
+  
+  attr_accessor :_text
+
+  # The view of this element.
+  
+  attr_accessor :_view
+
+  # The id of this element.
+  
+  attr_accessor :id
+
+  def initialize(*args)
+    @_children = {}
+    @_text = ''
+    @id = self.class.to_s.demodulize.underscore
+  end
+    
+  # Prepend this code to the element content.
+  
+  def open
+  end
+  
+  # If an optional name parameter is passed renders
+  # the content of the named child element.
+  #
+  # eg. #{content :child_element_id}
+  #
+  # === Example
+  #
+  # <Page>
+  #   ..
+  #
+  #   <Box id="hello">
+  #     ..
+  #   </Box>
+  #
+  #   <Box id="world">
+  #     ..
+  #   </Box>
+  #
+  #   <Sidebar>
+  #     ..
+  #   </Sidebar>
+  #
+  #   ..
+  #
+  # </Page>
+  #
+  # Access children content from within the enclosing element
+  # (Page) like this:
+  #
+  # {content :hello}
+  # {content :world}
+  # {content :sidebar}  
+  
+  def content(cname = nil)
+    if cname
+      if c = @_children[cname.to_s]
+        c.content
+      else
+        return nil
+      end
+    else
+      @_text
+    end
+  end
+  
+  # Include a text file in the element template. All the 
+  # conventions of the StaticInclude compiler apply here. Please
+  # not that unless you pass an absolute path (starting with 
+  # '/') you have to pass a controller instance as well.
+  # 
+  # === Example:
+  #
+  # def render
+  #   %~
+  #   <div>
+  #     #{include '/links/latest'}
+  #   </div>
+  #   ~
+  # end
+  
+  def include(href, controller = nil)
+    filename = StaticIncludeFilter.new.resolve_include_filename(href)
+    return File.read(filename)
+  end
+  
+  # Append this code to the element content.
+  
+  def close
+  end  
+
+  # Override this.
+  
+  def render
+    "#{open}#{content}#{close}"
+  end
+
+  def render_children
+    str = ''
+    for c in @_children.values
+      str << c.render
+    end
+    
+    return str
+  end  
+
+  def add_child(child)
+    child._parent = self
+    @_children[child.instance_variable_get('@id')] = child
+  end
+  
+  alias_method :children, :_children  
+  
+end
+
+# A programmatically generated element.
+#
+# === Usage
+#
+# = in the code
+# 
+# class Page < Nitro::Element
+#   def render
+#     %{
+#     <div id="@id">#{content}</div>
+#     }
+#   end
+# end
+# 
+# = in your template
+#
+# <Page>hello</Page>
+# 
+# => <div id="page">hello</div>
+#
+# the id is automatically fille with the class name using 
+# class.method_name eg. MyModule::MyPage => my_module__my_page
+#
+# you can override the id to use the element multiple times on 
+# the page.
+#
+# == Sub Elements
+#
+# Elements can be imbricated. To render the the child element in 
+# the parent's template, use #{content :element_id}
+# 
+# === Design
+#
+# An underscore is used for the standard attibutes to avoid name 
+# clashes.
+
+class Element
+  include ElementMixin
+  
+  # The prefix for element tags (in xhtml compatibility mode)
+  
+  setting :prefix, :default => 'x', :doc => 'The prefix for element tags'
+
+  # Allow auto extension of element classes?
+  
+  setting :auto_extend, :default => true, :doc => 'Allow auto extension of element classes?'
+end
+
+end