ruby-web 1.1.1

data/lib/web/traceoutput.rb

@@ -0,0 +1,75 @@
+# TODO: trace output is woefully broken
+
+# TODO: formerly on Web::close:
+# if Web::display_trace
+#   trace_output
+# end
+
+
+module Web
+  # Web::display_trace controls the display of trace variables
+  @@display_trace = false
+  class << self
+    attr_accessor :display_trace
+  end
+
+  TRACE_STYLESHEET=<<-EOF
+<style type="text/css">
+span.tracecontent { background-color:white; color:black;font: 10pt verdana, arial; }
+span.tracecontent table { font: 10pt verdana, arial; cellspacing:0; cellpadding:0; margin-bottom:25}
+span.tracecontent tr.subhead { background-color:cccccc;}
+span.tracecontent th { padding:0,3,0,3 }
+span.tracecontent th.alt { background-color:black; color:white; padding:3,3,2,3; }
+span.tracecontent td { padding:0,3,0,3 }
+span.tracecontent tr.alt { background-color:eeeeee }
+span.tracecontent h1 { font: 24pt verdana, arial; margin:0,0,0,0}
+span.tracecontent h2 { font: 18pt verdana, arial; margin:0,0,0,0}
+span.tracecontent h3 { font: 12pt verdana, arial; margin:0,0,0,0}
+span.tracecontent th a { color:darkblue; font: 8pt verdana, arial; }
+span.tracecontent a { color:darkblue;text-decoration:none }
+span.tracecontent a:hover { color:darkblue;text-decoration:underline; }
+span.tracecontent div.outer { width:90%; margin:15,15,15,15}
+span.tracecontent table.viewmenu td { background-color:006699; color:white; padding:0,5,0,5; }
+span.tracecontent table.viewmenu td.end { padding:0,0,0,0; }
+span.tracecontent table.viewmenu a {color:white; font: 8pt verdana, arial; }
+span.tracecontent table.viewmenu a:hover {color:white; font: 8pt verdana, arial; }
+span.tracecontent a.tinylink {color:darkblue; font: 8pt verdana, arial;text-decoration:underline;}
+span.tracecontent a.link {color:darkblue; text-decoration:underline;}
+span.tracecontent div.buffer {padding-top:7; padding-bottom:17;}
+span.tracecontent .small { font: 8pt verdana, arial }
+span.tracecontent table td { padding-right:20 }
+span.tracecontent table td.nopad { padding-right:5 }
+</style>
+EOF
+
+  class Connection
+    def Connection.trace_output_template
+	    template = <<-EOF
+<div>
+<h1>Request Details</h1><br>
+<table cellspacing="0" cellpadding="0" border="1" style="width:100%;border-collapse:collapse;">
+<tr>
+  <th class="alt" align="Left" colspan=2><h3><b>Request Parameters</b></h3></th></tr>
+  <narf:foreach from=parameters item=parameter>
+    <tr><th width=150>{$parameter.key}</th><td>{$parameter.value}</td></tr>
+  </narf:foreach>
+</table>
+<br>
+<table cellspacing="0" cellpadding="0" border="1" style="width:100%;border-collapse:collapse;">
+  <tr><th class="alt" align="Left" colspan=2><h3><b>Cookies</b></h3></th></tr>
+  <narf:foreach from=cookies item=cookie>
+    <tr><th  width=150>{$cookie.key}</th><td>{$cookie.value}</td></tr>
+  </narf:foreach>
+</table>
+<br>
+<table cellspacing="0" cellpadding="0" border="1" style="width:100%;border-collapse:collapse;">
+  <tr><th class="alt" align="Left" colspan=2><h3><b>Session</b></h3></th></tr>
+  <narf:foreach from=session item=sessionitem>
+    <tr><th  width=150>{$sessionitem.key}</th><td>{$sessionitem.value}</td></tr>
+ </table>
+</div>
+EOF
+    end
+  end
+end
+

data/lib/web/unit.rb

@@ -0,0 +1,56 @@
+require 'web'
+require 'webunit/webunit'
+
+module Web
+  module Unit
+    include WebUnit
+    include WebUnit::Utils
+    attr_reader :response
+
+    def setup_webunit
+      @urlbase = ENV['URLBASE'] ? ENV['URLBASE'] : 'http://localhost/'
+      @urlbase = orthop_url( @urlbase )
+      @urlbase << '/' unless @urlbase =~ %r!/$!
+      $stderr.puts "URLBASE is #{@urlbase}" if $DEBUG
+      $URLBASE = @urlbase
+      WebUnit::Response::reset
+      @cookies_kept = WebUnit::Cookies::instance.cookies
+      Web::cookie::clear
+    end
+
+   def update_cookies
+     Web::cookie = Hash.new
+      Cookies.instance.cookies.each do |k, v|
+        Web::cookie[k.first] = v['value']
+      end
+   end
+
+   def reverse_update_cookies
+     Cookies::clear
+     Web::cookie.each do |k,v|
+       Cookies::add( k, v )
+     end
+   end
+
+    def do_request( url, params={} )
+      reverse_update_cookies
+      url = @urlbase + url unless (url.index(@urlbase) == 0)
+      @response = Response::get( url )
+      update_cookies
+    end
+  
+    def do_submit( params={} )
+      reverse_update_cookies
+      form = @response.form
+      params.each do |k,v|
+        form.params[k].value = v
+      end
+      @response = form.submit
+      update_cookies
+    end
+
+    def assert_title( expected, document=@response )
+      assert_equal( expected, document.title )
+    end
+  end
+end

data/lib/web/upload.rb

@@ -0,0 +1,59 @@
+require 'tempfile'
+
+module Web
+  # == Purpose
+  # This class delegates to the uploaded Tempfile, and adds
+  # content type and original filename attributes.
+  #
+  # If you are testing a multipart/form, use this class
+  # to pretend you uploaded a file:
+  #
+  #     "uploaded_file" => Upload.new(anIO,
+  #                                   "image/png",
+  #                                   "my_favorite_image.png" )
+  #
+  # See Web::Testing for more information.
+  #
+  class Upload
+    attr_reader :content_type, :original_filename
+    
+    def initialize( tempfile, content_type, original_filename )
+      if (tempfile.is_a? String)
+        contents = File.open( tempfile, "r" ) { |f| f.read }
+        tempfile = Tempfile.new("Web")
+        tempfile.binmode
+        tempfile.write contents
+        tempfile.rewind
+      end		
+      
+      @content_type = content_type
+      @original_filename = original_filename
+      @tempfile = tempfile
+    end
+
+    def local_path
+      @tempfile.path
+    end
+
+    # use this method to move an upload somewhere you care about
+    def save( filename )
+      File.open( filename, "w" ) { |f|
+        f.binmode
+        f.write( self.read )
+      }
+    end
+    
+    # how do I get the contents of an upload?
+    def read
+      @tempfile.rewind
+      @tempfile.read
+    end
+    
+    # how do I get in IO object from an upload?
+    def open
+      @tempfile.rewind
+      yield @tempfile
+    end
+  end
+
+end

data/lib/web/validate.rb

@@ -0,0 +1,52 @@
+module Web
+  def Web::rule( params = {} )
+    Web::ruleset ||= Array.new
+    Web::ruleset.push Rule.new( params )
+  end
+
+  def Web::validate
+    problems = Array.new
+    Web::ruleset.each do |r|
+      unless Web[r.field] =~ r.regexp
+        problems.push r
+        raise Web::FatalValidationError.new(r) if (r.malformed == :fatal)
+      end
+    end
+    problems
+  end
+
+  class Connection
+    attr_accessor :ruleset
+  end
+
+  class Web::FatalValidationError < Error
+    attr_reader :rule
+    def initialize( rule )
+      @rule = rule
+      super( rule.message )
+    end
+  end
+
+  class Rule
+    attr_reader :field, :regexp, :message, :malformed
+    def initialize( params = {} )
+      [:field, :regexp].each do |k|
+        unless params.has_key? k
+          raise ArgumentError.new( "Web::rule is missing required parameter (:#{k})" )
+        else
+          self.instance_variable_set("@#{k}".intern, params[k] )
+        end
+      end
+      
+      [:message, :malformed ].each do |k|
+        if params.has_key? k
+          self.instance_variable_set("@#{k}".intern, params[k] )
+        end
+      end
+
+      @field = @field.to_s      
+      @malformed ||= :continue
+
+    end
+  end
+end

data/lib/web/wiki.rb

@@ -0,0 +1,557 @@
+require 'web'
+require 'web/wiki/linker'
+require 'web/wiki/page'
+require 'yaml'
+require 'ftools'
+require 'strscan'
+require 'ipaddr'
+
+module Web
+  # == Purpose
+  # This wiki exists to:
+  #     * Serve http://www.narf-lib.org
+  #     * Test the utility of features in the NARF toolkit, and serve
+  #       as an example of how to build a decent-sized application
+  #       with NARF
+  #     * Be a nice, useful wiki; aka UseMod with HTMLArea integration
+  #       and image uploads
+  #
+  # == Usage
+  # This is the quickest way to embed the narf wiki:
+  #
+  #    #!/usr/bin/env ruby
+  #    require 'web/wiki'
+  #    Web::process{
+  #      Web::Wiki::handle_request()
+  #    }
+  # 
+  # You will enjoy your wiki more, however, by fiddling with
+  # a few config settings. Here what a production wiki.rb might
+  # look like:
+  #
+  #    #!/usr/bin/env ruby
+  #    require 'web/wiki'
+  #    
+  #    Web::process{
+  #      # this line allows me to overload the default templates
+  #      Web::config[:load_path] << "../"
+  #
+  #      # here I set a number of config variables.
+  #      Web::Wiki::set_pref( :store_url  => "/pages/",
+  #                           :store_dir  => "../pages/",
+  #                           :home_page  => "NarfRocks",
+  #                           :resourceurl => "/resources" )
+  #
+  #      # finally, I handle the request
+  #      Web::Wiki.handle_request
+  #    }
+  #
+  # The default templates for the NARF wiki are located in
+  #
+  #     site_lib/web/wiki/resources/
+  # 
+  # Append your template dir to the :load_path and
+  # only worry about overriding the templates you care about.
+  # Chances are, you'll care about these two templates:
+  # 
+  # template.html:: the overall template
+  # home.html:: the template for the  homepage
+  # 
+  # The following preferences can make a difference for
+  # your wiki:
+  #
+  # store_dir::
+  #     Web::Wiki uses YAML to save pages.  By default,
+  #     these pages will be saved in "./pages/".
+  # store_url::
+  #     If you make your store files publicly accessible,
+  #     Web::Wiki can let the webserver handle any the download
+  #     of any upload page assets.
+  # home_page::
+  #     The default home page for the wiki is HomePage.  Set the
+  #     HomePage to something meaningful in your wiki.
+  # resourceurl::
+  #     By default, the NARF wiki will download various resource files
+  #     from sitelib/web/wiki/resources.  This makes installation easy,
+  #     but a single visit to the edit page will incur the hit of
+  #     executing ruby for every single image.  Make these files
+  #     accessible online and tell NARF where to find them, and
+  #     things should run more quickly.
+  # 
+  # == Credits
+  # Web::Wiki must extend its thanks to these very, very useful projects:
+  #
+  # YAML:: http://yaml4r.sourceforge.net/
+  # HTMLArea:: http://sourceforge.net/projects/itools-htmlarea/
+  #
+  class Wiki
+
+    # It seems nicer to define the class
+    # methods on an object and
+    # delegate a few class methods
+    def Wiki.method_missing( symbol, *args )
+      if [:handle_request,
+          :store_dir,
+          :store_url,
+          :store_basedir,
+          :more_news,
+          :page_list,
+          :open_permissions ].include? symbol 
+        wiki.send symbol, *args
+      else
+        super( symbol, args )
+      end
+    end
+    
+    @@wiki = nil
+    def Wiki.wiki
+      @@wiki ||= Wiki.new
+    end
+    
+    def Wiki.wipe #:nodoc:
+      @@wiki = nil
+    end
+    
+    @@preferences = nil
+    def Wiki.preferences
+      @@preferences ||= {"baseurl" => Web::script_name,
+                         "resourceurl" => "{$baseurl}/resources",
+                         "store_dir" => "./pages/",
+                         "tarpit_dir" => "./tarpit/",
+                         "resource_dir" => File.join( File.dirname( __FILE__ ),
+                                                      "wiki",
+                                                      "resources" ),
+                         "vandals" => "vandals.txt",
+                         "home_page" => "HomePage",
+                         "home_template" => "home.html",
+                         "allowed_actions" => Wiki::Request.actions.keys
+      }
+    end
+
+    def Wiki.pref( key )
+      key = key.to_s unless (key.kind_of? String)
+      pref = Wiki.preferences[key]
+      while (pref =~ /\{\$([^\}]*)\}/)
+        variable = $1
+        pref.gsub!( /\{\$#{variable}\}/, Wiki.pref( variable.strip ) || "")
+      end
+      pref
+    end
+
+    def Wiki.set_pref( new_prefs={} )
+      new_prefs.each{ |key,value|
+        key = key.to_s unless (key.kind_of? String) 
+        Wiki.preferences[key] = value
+      }
+    end
+    #-------------------------------------------------------------
+    
+    module Store #:nodoc:
+      
+      def move_asset( from, filename )
+        historical = File.expand_path(filename)
+        i=0
+        while( File.exists? historical )
+          i += 1
+          historical = File.dirname( historical ) + "/\#" + i.to_s + "." + File.basename( historical ).gsub( /^\#\d*\./, "" )
+        end
+        
+        File.move( filename, historical ) if File.exists? filename
+
+        if (from.is_a? Web::Upload)
+          from.save(filename)
+        else
+          File.move( from, filename )
+        end
+      end
+      
+      def page_list
+        Dir[store_dir + "/*.yaml"].entries.collect { |e|
+          File.basename( e, ".yaml" ).gsub( /-slash-/, "/" )
+        }
+      end
+      
+      def store( name )
+        File.join( store_dir, name.gsub(/\//, "-slash-") + ".yaml" )
+      end
+      
+      def load_page( name = Web["page.name"] )
+        if name.size == 0
+          if (Web.path_info)
+            name = Web.path_info.gsub( Regexp.new(Web.script_name), "" ).gsub(/^\/|\.html$/,"")
+          end
+          if name.size == 0
+            name = Web::Wiki::pref( :home_page )
+          end
+        end
+        
+        page = ""
+        page_file = store( name )
+        if File.exists? page_file
+          File.open( page_file, "r" ) { |f|
+            page = YAML.load( f )
+          }
+        else
+          page = Web::Wiki::Page.new( name )
+        end
+        
+        {/\\r/ => "\r",
+         /\\n/ => "\n",
+         /\\"/ => "\"",
+         /\\'/ => "'",  }.each{ |find, replace|
+          page.content.gsub!( find, replace )
+        }
+        page
+      end
+      
+      def news
+        more_news[0..4]
+      end
+      
+      def more_news
+        if File.exists?(store_dir + "/more_news.yaml")
+          contents = File.open( store_dir + "/more_news.yaml" ) { |f| f.read }
+          unless contents.empty?
+            YAML.load(contents)
+          else
+            [ ]
+          end
+        else
+          [ ]
+        end
+      end
+      
+      def recent
+        if File.exists?(store_dir + "/recent.yaml")
+          contents = File.open( store_dir + "/recent.yaml" ) { |f| f.read }
+          unless contents.empty?
+            YAML.load(contents)
+          else
+            [ ]
+          end
+        else
+          [ ]
+        end
+      end
+      
+      def save( page )
+        # save a slim version of the page for recent changes
+        rcpage = page.clone
+        rcpage.content = ""
+        rcpage.history = [ ]
+
+        rc = more_news
+        rc = rc.unshift(rcpage) unless rcpage.comment.empty?
+        rc.pop if rc.size > Page::max_revisions
+        yaml = rc.to_yaml
+        File.open( store_dir + "/more_news.yaml", "w" ) { |f|
+          f.write(yaml)
+        }
+
+        rc = recent
+        rc = rc.unshift(rcpage)
+        
+        recent_page_names = [ ]
+        rc.delete_if do |p|
+          if recent_page_names.include? p.name
+            true
+          else
+            recent_page_names.push p.name
+            false
+          end
+        end
+        rc.pop if rc.size > Page::max_revisions
+        yaml = rc.to_yaml
+        File.open( store_dir + "/recent.yaml", "w" ) do |f|
+          f.write(yaml)
+        end
+        
+        comment = page.comment
+        # clear out comment now that we've saved more news
+        page.comment = ""
+        yaml = page.to_yaml
+        File.open( store( page.name ), "w" ) { |f|
+          f.write(yaml)
+        }
+      end
+      
+
+      def store_basedir
+        if ( vandal? )
+          Wiki.pref( "tarpit_dir" )
+        else
+          Wiki.pref( "store_dir" )
+        end
+      end
+
+      def store_dir
+        unless (File.exists? store_dirname)
+          File.makedirs( store_dirname)
+        end
+        store_dirname
+      end
+
+      def store_url
+        Wiki::pref( :store_url ) || Wiki::pref( :store_dir )
+      end
+      
+      def store_dirname
+        unless ( store_basedir =~ /^(\w:)?\// )
+          File.expand_path( Dir.pwd + "/" + self.store_basedir )
+        else
+          store_basedir
+        end
+      end
+
+      def vandal?
+        vandal = false
+        vandals.each do |pattern|
+          if pattern =~ ENV["REMOTE_ADDR"]
+            vandal = true
+            break
+          end
+        end
+        vandal
+      end
+      
+      def vandals
+        @vandals ||= if File.exists?( Wiki.pref("vandals") || "" )
+                       File.open( Wiki.pref("vandals") ) { |f|
+                         f.to_a
+                      }.collect{ |line|
+                         /^#{line.chomp.strip.gsub(/"/, '')}/
+                      }
+                     else
+                       [ ]
+                     end
+      end
+      
+      def open_permissions
+        require 'find'
+        Find.find( store_dir ) { |name|
+          begin
+            if File.directory? name
+              File.chmod( 0777, name )
+            else
+              File.chmod( 0666, name )
+            end
+          rescue Exception
+            # this should be more specific to access errors
+          end
+        }
+      end
+
+    end
+    
+    include Wiki::Store
+    
+    #-------------------------------------------------------------
+
+    def handle_request
+      Request.new( self ).handle_request
+      #unless (Wiki.pref("added_exit_handler"))
+      #  
+      #  Wiki.set_pref("added_exit_handler" => true )
+      #end
+    end
+    
+    class Request # :nodoc:
+      
+      attr_accessor :template, :content_template, :wiki
+      
+      def initialize( wiki )
+        @page = @handled = false
+        @wiki = wiki
+        @template = if (File.basename(Web.script_name || '') == "admin.rb")
+                      "admin.html"
+                    else
+                      "template.html"
+                    end
+      end
+      
+      attr_writer :page
+      def page
+        unless @page
+          @page = self.wiki.load_page
+          unless (Web["revision"] == nil || Web["revision"].empty? || Web["revision"].to_s == "0")
+            history = @page.history
+            revision = history.find{ |p|
+              Web["revision"].to_i == p.revision
+            }
+            revision.history = history
+            @page = revision || @page
+          end
+        end
+        @page
+      end
+
+      attr_writer :vars
+      def vars
+        @vars ||= {"page"    => self.page,
+                   "wiki"    => self.wiki,
+                   "action"  => Web["action"],
+                   "baseurl" => Web::Wiki::pref(:baseurl),
+                   "resourceurl" => Web::Wiki::pref(:resourceurl),
+        }
+      end
+      
+      def handle_request
+        cmd = Web["action"]
+        cmd = "default" if cmd.empty? || cmd == "view_revision"
+        cmd = "download_resource" if Web::path_info =~ /^\/resources\//
+        cmd = "default" unless Web::Wiki::pref("allowed_actions").include?(cmd)
+        
+        Request.actions[cmd].call(self)
+        
+        
+        unless @handled
+          Web::config[:load_path] << Web::Wiki::pref("resource_dir")
+          self.vars["content_template"] = self.content_template
+          Web::local.merge!( self.vars )
+          Web::load( self.template ) if self.template
+          @handled = true
+        end
+      end
+      
+      @@actions = {}
+      def Request.actions
+        @@actions
+      end
+      
+      def Request.action( name, &action )
+        Action.new name, &action
+      end
+
+      
+      class Action #:nodoc:
+        attr_accessor :name
+        def initialize( name, &action )
+          @name = name
+          @action = action
+          Request.actions[name] = self
+        end
+        
+        def call( request )
+          if (self.name == "default")
+            request.content_template = request.page.template
+          else
+            request.content_template = self.name + ".html"
+          end
+          @action.call(request) if @action
+          if ( [ "illustration.html",
+                "images.html" ].include? request.content_template )
+            request.template = request.content_template
+          end
+        end
+      end
+      
+      [ "default", "page_history", "images", "more_news" ].each{ |boring_action|
+        action( boring_action )
+      }
+      
+      #action( "more_news_rss_0.91" ) {|r|
+      #  r.template = "more_news_rss_0.91.html"
+      #}
+      
+      action( "edit" ) { |r|
+        r.page.comment = "";
+        r.vars["options"] = {
+          "content_editor" => case Web::env["http_user_agent"]
+                              when /MSIE.*Windows/
+                                "ie-content_editor.html"
+                              when /Mozilla.*(?!MSIE).*Windows/
+                                "ekit-content_editor.html"
+                              else
+                                "default-content_editor.html"
+                              end,
+                             "page_types" => ["Normal", "Illustration"],
+                             "align"      => ["left", "center", "right"],
+                             "valign"     => ["top",  "middle", "bottom"],
+        }
+      }
+      
+      def download_file( basedir, requested_asset )
+        self.template = nil
+        self.content_template = nil
+
+        basedir = File.expand_path( basedir )
+        requested_asset = File.expand_path( File.join(basedir,
+                                                      requested_asset.gsub( /\\/, "/") ) )
+        # security check on the requested_asset --
+        # it must be underneath the basedir
+        if ( requested_asset.index( basedir ) == 0 && \
+             File.exists?( requested_asset ) )
+          # deliver the file
+          Web.content_type = Web.get_mime_type( requested_asset )
+          Web.write File.open(requested_asset, "r" ) { |f|
+            f.read
+          }
+          Web.flush
+        else
+          Web.status = "404";
+          Web.write "404 File Not Found"
+          Web.flush
+        end
+      end
+      
+      action( "download" ) { |r|
+        r.download_file( r.page.dir,Web["asset"] )
+      }
+      
+      action("download_resource") { |r|
+        r.download_file( Wiki::pref(:resource_dir),
+                         Web::path_info.gsub( /^\/resources/, '' ) )
+      }
+    
+      
+
+      ["select_illustration", "insert_download"].each{ |images_target|
+        action(images_target) { |r|
+          r.template = "images.html"
+        }
+      }
+
+      action( "Upload" ) { |r|
+        r.content_template = "images.html"
+        r.vars["action"] = Web["calling_action"]
+        Dir.mkdir r.page.dir unless (File.exists? r.page.dir)
+        r.wiki.move_asset( Web["upload"],
+                           File.join( r.page.dir,
+                                      File.basename(Web["upload"]                 \
+                                                    .original_filename            \
+                                                    .gsub( /\\/, "/") ) ) )
+      }
+      
+      action( "asset_history" ) { |r|
+        r.vars["asset"] = { "name" => Web["asset"],
+                           "history" => r.page.historical_assets[Web["asset"]] }
+      }
+      
+      action( "Save" ) { |r|
+        # patrick's (seemed simpler at the moment)
+        # comment out if you want to try the
+        # simple dispatcher code below
+        r.page.set_by_request
+        r.wiki.save( r.page )
+
+        # redirect back to default
+        Web::request["action"] = ["default"]
+        Web::clear()
+        r.handle_request
+      }
+      
+      
+
+      action( "delete_asset" ) { |r|
+        r.content_template = "images.html"
+        r.vars["action"] = Web["calling_action"]
+        r.wiki.move_asset( File.join( r.page.dir, File.basename( Web["asset"] ) ),
+                           File.join( r.page.dir, File.basename( "\#deleted." + Web["asset"] ) ) )
+      }
+      
+    end
+    
+  end
+end
+
+Wiki = Web::Wiki