narf 0.6.2 → 0.6.3

data/lib/web/unit/ui/cui/testrunner.rb~

@@ -1,50 +0,0 @@
-require 'web/unit/converter'
-
-module WebUnit #:nodoc: all
-  module UI
-    module CUI
-      class TestRunner
-
-        def initialize(quiet_mode=true)
-          case USING_FRAMEWORK
-          when 'Test::Unit'
-            require 'test/unit/ui/console/testrunner'
-            @runner = Test::Unit::UI::Console::TestRunner
-          when 'RubyUnit'
-            require 'runit/cui/testrunner'
-            @runner = RUNIT::CUI::TestRunner.new
-          end
-          quiet_mode(quiet_mode)
-        end
-
-        def quiet_mode(boolean)
-          case USING_FRAMEWORK
-          when 'RubyUnit'
-            @runner.class.quiet_mode = boolean
-          end
-        end
-
-        def all_suite
-          case USING_FRAMEWORK
-          when 'Test::Unit'
-            suite_name = $0.sub(/\.rb$/, '')
-            suite = TestSuite.new(suite_name)
-            test_classes = []
-            ObjectSpace.each_object(Class) do |klass|
-              test_classes << klass if TestCase > klass
-            end
-            test_classes.each {|klass| suite << klass.suite}
-            suite
-          when 'RubyUnit'
-            TestCase.all_suite
-          end
-        end
-
-        def run(suite=all_suite)
-          @runner.run(suite)
-        end
-
-      end
-    end
-  end
-end

data/lib/web/upload.rb~

@@ -1,262 +0,0 @@
-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
-    
-    # use this method to move an upload somewhere you care about
-    def write_to_file( 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
-  
-  
-  
-  # === Purpose
-  # Web::Request parses the cookies and parameters and contains methods to access them.
-  #
-  module Request #:nodoc:
-    def Request.normalize( params )              #:nodoc:
-      params.each { |key, value|
-        unless value.kind_of? Array
-          params[key] = [value]
-        end
-      }
-      params.default = []
-      params
-    end
-    
-    def Request.cookies(mock=nil)
-      Request.normalize( mock || Request.parse_cookie( ENV['HTTP_COOKIE'] || ENV['COOKIE'] ) )
-    end
-    
-    def Request.parse_cookie(raw_cookie) #:nodoc:
-      cookies = Hash.new([])
-      return cookies unless raw_cookie
-      
-      raw_cookie.split(/; /).each do |pairs|
-        name, values = pairs.split('=',2)
-        name = Web::unescape(name)
-        values ||= ""
-        values = values.split('&').collect{|v| Web::unescape(v) }
-        if cookies.has_key?(name)
-          cookies[name].push(*values)
-        else
-          cookies[name] = values
-        end
-      end
-      
-      cookies
-    end    
-    
-    def Request.parse             #:nodoc:
-      if (multipart?)
-        parse_multipart
-      else
-        parse_query_string( query_string )
-      end
-    end
-    
-    def Request.query_string
-      case ENV["REQUEST_METHOD"]
-      when "GET", "HEAD"
-        if (defined? MOD_RUBY) # <= this check is untested.
-          #    search the test files for
-          #    test_parse_get_with_mod_ruby
-          #    for an explanation
-          mod_ruby_query_string
-        else
-          ENV["QUERY_STRING"]
-        end
-      when "POST"
-        $stdin.binmode
-        $stdin.read(Integer(ENV['CONTENT_LENGTH']))
-      end
-    end
-    
-    # this method solely exists b/c of difficulties setting MOD_RUBY dynamically.
-    # so this method exists so I can test the effect separately
-    # from the (currently untestable) cause
-    def Request.mod_ruby_query_string     #:nodoc:
-      Apache::request.args
-    end
-    
-    def Request.parse_query_string(query) #:nodoc:
-      query ||= ""
-      params = Hash.new([])
-      
-      query.split(/[&;]/n).each do |pairs|
-        key, value = pairs.split('=',2).collect{|v| Web::unescape(v) }
-        if params.has_key?(key)
-          params[key].push(value)
-        else
-          params[key] = [value]
-        end
-      end
-      
-      params
-    end
-    
-    
-    # note this returns the un-arrayified version of the array
-    def Request.parse_query_string_typed(query) #:nodoc: :notest:
-      params = parse_query_string query
-      params2 = {}
-      params.collect do |k,v|
-        if ! (k =~ /type/)
-          if (atype = params["#{k}#type"][0]) 
-            params2[k] = Module.const_get(atype.intern).unencode(v[0])
-          else
-            params2[k] = v[0]
-          end
-        end
-      end
-      params2
-    end
-    
-    def Request.multipart?
-      ("POST" == ENV['REQUEST_METHOD']) &&
-            (/multipart\/form-data/.match(ENV['CONTENT_TYPE']))
-    end
-    
-    def Request.parse_multipart    #:nodoc:
-      %r|\Amultipart/form-data.*boundary=\"?([^\";,]+)\"?|n.match(ENV['CONTENT_TYPE'])
-      boundary = $1.dup
-      
-      read_multipart(boundary, Integer(ENV['CONTENT_LENGTH']))
-    end
-    
-    EOL="\r\n"
-    
-    def Request.read_multipart(boundary, content_length)  #:nodoc:
-      params = Hash.new([])
-      boundary = "--" + boundary
-      buf = ""
-      bufsize = 10 * 1024
-      
-      # start multipart/form-data
-      $stdin.binmode
-      boundary_size = boundary.size + EOL.size
-      content_length -= boundary_size
-      status = $stdin.read(boundary_size)
-      if nil == status
-        raise EOFError, "no content body"
-      end
-      
-      until -1 == content_length
-        head = nil
-        body = Tempfile.new("Web")
-        body.binmode
-        
-        until head and /#{boundary}(?:#{EOL}|--)/n.match(buf)
-          
-          if head
-            trim_size = (EOL + boundary + EOL).size
-            if trim_size < buf.size
-              body.print buf[0 ... (buf.size - trim_size)]
-              buf[0 ... (buf.size - trim_size)] = ""
-            end
-          elsif /#{EOL}#{EOL}/n.match(buf)
-            buf = buf.sub(/\A((?:.|\n)*?#{EOL})#{EOL}/n) do
-              head = $1.dup
-              ""
-            end
-            next
-          end
-          
-          c = if bufsize < content_length
-                $stdin.read(bufsize) or ''
-              else
-                $stdin.read(content_length) or ''
-              end
-          buf.concat c
-          content_length -= c.size
-          
-        end
-        
-        
-        /Content-Disposition:.* filename="?([^\";]*)"?/ni.match(head)
-        filename = ($1 or "").dup
-        if /Mac/ni.match(ENV['HTTP_USER_AGENT']) and
-            /Mozilla/ni.match(ENV['HTTP_USER_AGENT']) and
-            (not /MSIE/ni.match(ENV['HTTP_USER_AGENT']))
-          filename = Web::unescape(filename)
-        end
-        
-        /Content-Type: (.*)/ni.match(head)
-        content_type = ($1 or "").strip
-        
-        buf = buf.sub(/\A((?:.|\n)*?)(?:#{EOL})?#{boundary}(#{EOL}|--)/n) do
-          body.print $1
-          if "--" == $2
-            content_length = -1
-          end
-          ""
-        end
-        
-        body.rewind
-        
-        if (content_type.empty?)
-          upload = body.read
-        else
-          upload = Web::Upload.new( body, content_type, filename )
-        end
-
-        /Content-Disposition:.* name="?([^\";]*)"?/ni.match(head)
-        name = $1.dup
-        
-        if params.has_key?(name)
-          params[name].push(upload)
-        else
-          params[name] = [upload]
-        end
-        
-      end
-      
-      params
-    end # read_multipart
-    
-  end
-end

data/lib/web/wiki.rb~

@@ -1,517 +0,0 @@
-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::template_include_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 template_include_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,
-          :exit_handler ].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.write_to_file(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 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
-        File.open( store_dir + "/more_news.yaml", "w" ) { |f|
-          YAML.dump( rc, f )
-        }
-        
-        comment = page.comment
-        # clear out comment now that we've saved more news
-        page.comment = ""
-        File.open( store( page.name ), "w" ) { |f|
-          YAML.dump( page, f )
-        }
-      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 =~ /^\// )
-          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 exit_handler
-        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"))
-        exit_handler
-        Wiki.set_pref("added_exit_handler" => true )
-      end
-    end
-    
-    class Request # :nodoc:
-      
-      attr_accessor :page, :template, :content_template, :vars, :wiki
-      
-      def initialize( wiki )
-        @handled = false
-        @wiki = wiki
-        @template = if (File.basename(Web.script_name) == "admin.rb")
-                      "admin.html"
-                    else
-                      "template.html"
-                    end
-      end
-      
-      def page
-        unless @page
-          @page = self.wiki.load_page
-          unless (Web["revision"] == nil || Web["revision"].empty? || Web["revision"].to_s == "0")
-            history = @page.history
-            @page = history.find{ |p|
-              Web["revision"].to_i == p.revision
-            }
-            @page.history = history
-          end
-        end
-        @page
-      end
-      
-      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.template_include_path << Web::Wiki::pref("resource_dir")
-          self.vars["content_template"] = self.content_template
-          Web.print_template( self.template, self.vars ) 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 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::multiple_params["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