peekbot 0.0.1

data/dispatch.fcgi

@@ -0,0 +1,15 @@
+#!/usr/local/bin/ruby
+require 'rubygems'
+require 'camping'
+require 'camping/fastcgi'
+require 'peekbot'
+
+Camping::FastCGI.serve("peekbot.rb")
+
+FCGI.each do |req|
+#        req.out << "Content-Type: text/html\r\n\r\nHello, World!<br>\n"
+#        req.env.keys.sort.each {|k| req.out << "#{k}=#{req.env[k]}<br>\n"}        
+        camp_do(req)
+#        req.finish
+end
+

data/m.bat

@@ -0,0 +1,3 @@
+del peekbot-*.gem
+call gem uninstall peekbot
+ruby peekbot.gemspec

data/make_all_images.rb

@@ -0,0 +1,51 @@
+#!/usr/local/bin/ruby
+lib_path=File.expand_path(File.dirname(__FILE__)+"//..//ripxplore//lib")
+$:.unshift(lib_path) unless $:.include?(lib_path)
+
+lib_path=File.expand_path(File.dirname(__FILE__)+"//..//..//ripxplore//lib")
+$:.unshift(lib_path) unless $:.include?(lib_path)
+
+require 'RipXplore'
+require 'FileCache'
+PEEKBOT_URL_CACHE_DIR=File.dirname(__FILE__)+'/.image_cache'
+NATIVE_FILE_CACHE_PATH='/static/native_files'
+PEEKBOT_NATIVE_FILE_CACHE_DIR=File.dirname(__FILE__)+NATIVE_FILE_CACHE_PATH
+
+LAST_PEEKBOT_UPDATE=File.stat(__FILE__).mtime
+
+filecache=FileCache.new(PEEKBOT_URL_CACHE_DIR,PEEKBOT_NATIVE_FILE_CACHE_DIR)
+filecache.make_file_system_image_list
+all_image_urls=filecache.file_system_image_urls_in_cache    
+all_image_urls.reverse.each do |url|
+  puts "dumping #{url} at #{Time.now.to_s}"
+  begin
+  thread1=Thread.new do 
+      image=filecache.get_file_system_image(url)
+      puts "got image"
+      image.pictures.each do |picture|
+        local_filename=filecache.force_native_file_to_cache(picture,:to_picture,picture.picture_format.to_s)
+        puts "made picture #{local_filename}"
+      end
+      image.texts.each do |text|
+        if text.respond_to?(:to_screendump) then
+          local_filename=filecache.force_native_file_to_cache(text,:to_screendump,"png")
+          puts "made screendump #{local_filename}"
+        end
+      end
+
+    end
+    60.times do      
+      break unless thread1.alive?
+      sleep 1
+    end
+    if thread1.alive? then
+      puts "killing thread"
+      thread1.kill
+    end
+  rescue 
+    puts $!
+  end    
+end
+    
+
+

data/peekbot.rb

@@ -0,0 +1,599 @@
+$:.unshift(File.dirname(__FILE__)) unless
+	$:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+require 'rubygems'
+require 'camping'
+
+Markaby::Builder.set(:indent, 2)
+
+lib_path=File.expand_path(File.dirname(__FILE__)+"//..//ripxplore//lib")
+$:.unshift(lib_path) unless $:.include?(lib_path)
+
+lib_path=File.expand_path(File.dirname(__FILE__)+"//..//..//ripxplore//lib")
+$:.unshift(lib_path) unless $:.include?(lib_path)
+
+require 'peekbot_helper'
+
+require 'RipXplore'
+
+PEEKBOT_URL_CACHE_DIR=File.dirname(__FILE__)+'/.image_cache'
+NATIVE_FILE_CACHE_PATH='/static/native_files'
+PEEKBOT_NATIVE_FILE_CACHE_DIR=File.dirname(__FILE__)+NATIVE_FILE_CACHE_PATH
+
+LAST_PEEKBOT_UPDATE=File.stat(__FILE__).mtime
+
+require 'FileCache'
+@@filecache=FileCache.new(PEEKBOT_URL_CACHE_DIR,PEEKBOT_NATIVE_FILE_CACHE_DIR)
+
+
+Camping.goes :PeekBot
+
+@@images={}
+ def get_image(url)
+   if @@images[url].nil? then
+
+    @@images[url]=@@filecache.get_file_system_image(url)
+  end
+   @@images[url]
+end
+
+def local_mode?
+  remote_host=@env["REMOTE_ADDR"]
+  is_localhost=(remote_host=~/127\.0\.0\.1/)
+  is_localhost
+end
+def path_for_cached_native_file(native_file,method_to_cache,extension)
+  local_filename=@@filecache.force_native_file_to_cache(native_file,method_to_cache,extension)
+  local_filename.sub(PEEKBOT_NATIVE_FILE_CACHE_DIR,NATIVE_FILE_CACHE_PATH)
+end
+
+module PeekBot::Controllers
+
+
+# The root slash shows the `index' view.
+   class Index < R '/'
+     def get
+       if local_mode? then
+         redirect R(NavigateArchive,"file://#{Dir.getwd}")
+         else
+        render :index 
+        end
+     end
+   end
+
+   class HelpWanted < R '/help_wanted/'
+     def get
+       render :help_wanted 
+     end
+   end
+
+  class NavigateArchive < R '/navigate_archive/(.+)'
+    def get(archive_url)
+      @working_url=WorkingUrl.new(archive_url)
+      @images,@directories,@other_files=PeekBotHelper.get_archive_contents(@working_url.archive_url)      
+      render :navigate_archive
+    end
+  end
+
+class Static < R '/static/(.+)'
+    MIME_TYPES = {'.css' => 'text/css', '.js' => 'text/javascript', '.jpg' => 'image/jpeg,','.png' => 'image/png','.gif' => 'image/gif'}
+    PATH = File.expand_path(File.dirname(__FILE__))
+    def get(path)
+      @headers['Content-Type'] = MIME_TYPES[path[/\.\w+$/, 0]] || "text/plain"
+      unless path.include? ".." # prevent directory traversal attacks
+        @headers['X-Sendfile'] = "#{PATH}/static/#{path}"
+      else
+        @status = "403"
+        "403 - Invalid path"
+      end
+    end
+  end 
+
+ 
+  class CatalogImage < R '/catalog_image/(.+)'
+    def get(image_url)                  
+      @working_url=WorkingUrl.split_image_url_into_parts(image_url)
+      @image=get_image(@working_url.image_url)
+      render :catalog_image
+    end
+  end
+
+  class AllFilesOfType < R '/all_([^/]+)s/(.+)'
+    def get(filetype,image_url)          
+      @working_url=WorkingUrl.split_image_url_into_parts(image_url)
+      @image=get_image(@working_url.image_url)
+      render "all_#{filetype}s".to_sym
+    end
+  end
+  
+  class NativeFile < R '/native_file/(.+)/(\d+)'
+    def get(image_url,native_file_index)
+      @display_mode=input.display_mode
+      @working_url=WorkingUrl.split_image_url_into_parts(image_url)
+      @native_file_index=native_file_index
+      @image=get_image(@working_url.image_url)
+      @native_file=@image.files[native_file_index.to_i]
+      render :native_file
+    end
+  end
+
+  class SectorViewer < R '/sector_viewer/(.+)/(\d+)/(\d+)'
+    def get(image_url,track,sector)
+      @display_mode=input.display_mode
+      @working_url=WorkingUrl.split_image_url_into_parts(image_url)
+      @track=track.to_i
+      @sector=sector.to_i
+      @image=get_image(@working_url.image_url)
+      render :sector_viewer
+    end
+  end
+
+   class RandomFile < R '/random_([^/]+)/'
+     def get(filetype)
+      @random_filetype=filetype
+      random_filetype_collection_name="#{@random_filetype}s".to_sym
+      @image=@@filecache.random_file_system_image(random_filetype_collection_name)
+      @working_url=WorkingUrl.split_image_url_into_parts(@image.filename)
+      random_filetype_collection=@image.send(random_filetype_collection_name)
+      random_index=rand(random_filetype_collection.length) 
+      @native_file=random_filetype_collection[random_index]      
+       render :random_file
+     end
+   end
+
+# Any other page name gets sent to the view
+   # of the same name.
+   #
+   #   /index -> Views#index
+   #   /sample -> Views#sample
+   #
+   
+   class Page < R '/(\w+)'
+     def get(page_name)
+       render page_name
+     end
+   end
+
+ end
+
+
+module PeekBot::Views
+
+   # If you have a `layout' method like this, it
+   # will wrap the HTML in the other methods.  The
+   # `self << yield' is where the HTML is inserted.
+   def layout
+     html do
+      head do 
+        title 'peekbot' 
+        link :href=>R(Static,'style.css'), :rel=>'stylesheet', :type=>'text/css' 
+      end
+      body do 
+        self << header
+        self << yield 
+        self << footer
+      end
+#       footer { 'hello'}
+     end
+   end
+
+   # The `index' view.  Inside your views, you express
+   # the HTML in Ruby.  See http://code.whytheluckystiff.net/markaby/.
+   def index     
+     
+    text  "peekbot is an attempt to make vintage computing artifacts visible to the modern intarweb."
+    text  "It is a web proxy that allows navigation through online collections of disk images. "
+    text "For disk images in formats which peekbot understands, the file system contained on that disk image can be explored."
+    br
+    br
+    text "Many of the common file types found in the file systems can be converted to a format that can be viewed in a browser."
+    text "For example, tokenised BASIC files can be listed as ASCII, or (some) old graphic formats converted to PNG."
+    text "There is also a track/sector viewer, and any file found on a disk image can be viewed as a hex dump."
+    br
+    br
+    text "peekbot is based on"   
+    a 'ripxplore',:href=>'http://ripxplore.rubyforge.org/'  
+    text ", a ruby library for identifying and extracting data from disk images."
+    br
+    br
+    text "To get started, you could "
+    a 'view a random picture',:href=>R(RandomFile,:picture)
+    text" or else navigate with peekbot through some online disk image archives by clicking on one of the archive descriptions below."
+    br
+    br
+     ul do
+      [
+        ['http://cocomag.dyndns.org/swarc/',"Tim Lindner's Tandy Color Computer archive"],
+        ['http://mirrors.apple2.org.za/ftp.apple.asimov.net/',"Asimov Apple 2 image collections mirrored at apple2.org.za"],
+        ['http://mirrors.apple2.org.za/landover.no-ip.com/',"Landover Apple 2 image collections mirrored at apple2.org.za"],
+#        ['http://mirrors.apple2.org.za/',"Apple 2 image collections mirrored at apple2.org.za"],
+        ['http://www.atariarchives.org/oldhackers/',"Old Hackers Atari User Group Disk Archive (at AtariArchives.org)"],
+#        ['http://www.atariarchives.org/swlibrary/',"Atari Software Library (at AtariArchives.org)"],        
+#        ['http://www.cs.vu.nl/pub/ipoorten/atari.8bit/megazine/atr/','Atari Megazine archive'],
+        ['ftp://ftp.whtech.com/emulators/pc99/',"TI 99/4A archive at ftp.whtech.com"],
+        ['http://disk-images.jamtronix.com/ti99/',"Jamtronix mirror of TOSEC TI 99/4A collection"],
+        ['http://disk-images.jamtronix.com/coco/',"Jamtronix mirror of Tandy Color Computer dsks"],
+        ['http://www.classic-computers.org.nz/system-80/software_archive.htm',"Terry Stewart's collection of Dick Smith System 80 software"],
+#        ['http://disk-images.jamtronix.com/trs80/',"Jamtronix mirror of the Dutch TRS-80 usergroup collection (http://www.trs80.nl/)"],
+#        ['http://www.zimmers.net/anonftp/pub/cbm/c64/',"Bob Zimmerman's mirror of the FUNET C64 archive"],
+#        ['http://ftp.strassenbahn.tk:81/inntram-public/off-topic/c64/',"Strassenbahn.Tk C64 Archive"],
+#
+        ['http://www.zx81.nl/files.html','ZX81 archive at www.zx81.nl'],
+        ].each do |archive_url|
+        li do
+          a archive_url[1], :href=> R(NavigateArchive,archive_url[0]) 
+          #br
+          #text "[#{archive_url[0]}]"
+        end    
+      end
+    end
+    
+    br
+    text "NB - peekbot does not archive any images itself - they are all downloaded into peekbot from the referenced archive on demand."
+   end
+
+  def nav_bar
+    
+    return if @working_url.nil?
+    raise "security violation - only localhost can access file:// URLs" if @working_url.archive_url=~/^file:/ && ! (local_mode?)
+    raise 'invalid @working_url' unless @working_url.kind_of?(WorkingUrl)
+    
+    if ! @working_url.archive_url.nil? then      
+      text ' now peeking at : '
+      if @working_url.image_basename.nil? then
+        text URI.unescape(@working_url.archive_url)
+        a "[go direct]", :href=>@working_url.archive_url unless local_mode?
+      else 
+        a @working_url.archive_url, :href=> R(NavigateArchive,@working_url.archive_url)
+        if  @native_file.nil? then
+          a @working_url.image_basename, :href=> R(CatalogImage,@working_url.image_url)
+        else
+          a @working_url.image_basename, :href=> R(CatalogImage,@working_url.image_url)
+          text ' / '
+          text @native_file.filename
+        end
+      br
+      a "[download #{File.basename(@working_url.image_url)}]", :href=>@working_url.image_url unless local_mode?
+      end
+    end
+  end
+    def navigate_archive
+      
+      table {
+      tr.header { td { text "Navigation Options"}  }
+        @directories.each do |dirname|
+          tr.directory {            
+            td {a URI.unescape(dirname), :href=> R(NavigateArchive,PeekBotHelper.combine_url(@working_url.archive_url,dirname).to_s)}
+            td {}
+          }
+        end
+
+      tr.header { td { text "Peekable Images"}  }
+        @images.each do |filename|
+          tr.image {
+            td {
+              a 'explore', :href=> R(CatalogImage,PeekBotHelper.combine_url(@working_url.archive_url,filename))
+              if (! local_mode?) then
+                text ' | ' 
+                begin
+                  a 'download', :href=> PeekBotHelper.combine_url(@working_url.archive_url,filename).to_s
+                rescue  #nasty kludge but for the moment, just skip over filenames that URI doesn't like
+                end
+              end
+            }
+            td {text URI.unescape(filename) }
+          }
+        end
+      
+        if @other_files.length>0 then
+          tr.header { td { text "Other Files"}  }
+          @other_files.each do |filename|
+            tr.other_file {
+              td {
+                begin
+                  a 'download', :href=> PeekBotHelper.combine_url(@working_url.archive_url,filename).to_s
+                rescue  #nasty kludge but for the moment, just skip over filenames that URI doesn't like
+                end
+              }
+            td  {text URI.unescape(filename)}
+            } 
+          end
+        end
+      }
+    end
+     
+    def native_file
+      h3 @native_file.filename
+      case @display_mode
+        when 'hex' then
+          pre.hex_dump @native_file.to_hex_dump
+        when 'to_picture', 'to_png' then
+          scale =600/@native_file.picture_width
+          scale=1 if scale<1
+          img :src=>path_for_cached_native_file(@native_file,:to_picture,@native_file.picture_format.to_s),:width=>@native_file.picture_width*scale,:height=>@native_file.picture_height*scale
+        when 'to_screendump' then
+          #~ scale =800/@native_file.screendump_width
+          #~ scale=1 if scale<1
+          #~ img :src=>path_for_cached_native_file(@native_file,:to_screendump,"png"),:width=>@native_file.screendump_width*scale,:height=>@native_file.screendump_height*scale
+          center {
+            img :src=>path_for_cached_native_file(@native_file,:to_screendump,"png"),:width=>'80%'
+          }
+        else        
+          pre.text @native_file.send(@display_mode)
+        end
+    end
+
+    def all_pictures
+      h2 "VIEWING ALL PICTURES"
+      @image.pictures.each do |picture_file|
+        h3 picture_file.filename
+        scale =600/picture_file.picture_width 
+        scale=1 if scale<1
+        img :src=>path_for_cached_native_file(picture_file,:to_picture,picture_file.picture_format.to_s),:width=>picture_file.picture_width*scale,:height=>picture_file.picture_height*scale, :alt=>picture_file.filename
+      end
+    end
+
+    def all_texts
+      h2 "VIEWING ALL TEXT FILES"
+      @image.texts.each do |text_file|
+        h3 text_file.filename
+        pre text_file.to_text
+      end
+    end
+
+    def random_file
+      h2 "RANDOM #{@random_filetype.to_s.upcase}"
+      native_file=@native_file
+      text "Peekbot chose this #{@random_filetype.to_s} at random for you. It was found on a disk image that appears to have been originally for the #{@image.host_system.full_name}. You may like to look at:"
+      ul {
+        if (native_file.respond_to?(:to_screendump)) then
+          i=@image.files.index(native_file)
+          li {a "how this file would have looked on the #{@image.host_system.full_name} ", :href=> R(NativeFile,@working_url.image_url,i)+"?display_mode=to_screendump"}
+        end
+        li {a "all #{@image.files.length} files on this disk image", :href=> R(CatalogImage,@working_url.image_url)}
+        if @image.pictures.length>1 then
+          li {a "the #{@image.pictures.length} pictures on this disk image", :href=> R(AllFilesOfType,:picture,@working_url.image_url)}
+        end
+        if @image.texts.length>1 then
+          li {a "the #{@image.texts.length} texts on this disk image", :href=> R(AllFilesOfType,:text,@working_url.image_url)}
+        end
+        
+        [:picture,:text,:listing].each do |random_filetype|          
+          li {a "#{random_filetype.to_s== @random_filetype.to_s ? "another" : "a"} random #{random_filetype.to_s}", :href=> R(RandomFile,random_filetype)}
+        end
+      }
+      
+      h3 native_file.filename
+      if random_filetype.to_s==:picture.to_s then 
+        scale =600/native_file.picture_width
+        scale=1 if scale<1
+        img :src=>path_for_cached_native_file(native_file,:to_picture,native_file.picture_format.to_s),:width=>native_file.picture_width*scale,:height=>native_file.picture_height*scale, :alt=>native_file.filename
+      else
+        pre native_file.send("to_#{random_filetype}".to_sym)
+      end
+    end
+
+
+  def image_header
+   div.image_attributes do
+   h2 'image summary'
+   table.image_info do
+       [:host_system,:image_format,:file_system,:track_count,:volume_name].each do |att|
+        if (@image.respond_to?(att)) then
+            att_value=@image.send(att)
+          tr {           
+            td att.to_s
+            td att_value
+          } unless (att_value.nil? || att_value==0)
+        end 
+      end
+      if @image.pictures.length>0 then
+        tr {           
+            td "pictures"
+            td {
+            text @image.pictures.length 
+            a "VIEW ALL", :href=> R(AllFilesOfType,:picture,@working_url.image_url)
+            }
+          }
+      end
+      if @image.texts.length>0 then
+        tr {           
+            td "text files"
+            td {
+            text @image.texts.length 
+            a "VIEW ALL", :href=> R(AllFilesOfType,:text,@working_url.image_url)
+            }
+          }
+      
+    end
+        
+ 
+    end
+  end 
+end
+  
+  def track_list
+    div.track_list do
+      h3 'tracks'
+      @image.track_list.each do |track|
+        a "[%02X]" % track,:href=>R(SectorViewer,@working_url.image_url,track,@image.sectors_in_track(track)[0])+"\#sector_viewer",:rel=>"nofollow"
+        text " "
+      end
+    end unless @image.track_list.length==0
+  end
+  
+  def sector_viewer
+     image_header
+    div.sector_viewer do
+      h2 "sector viewer"
+      h3 {a "sectors in track $#{"%02x" % track}",:name=>"sector_viewer"}
+      @image.sectors_in_track(track).each do |sector| 
+        a "[%02X]" % sector,:href=>R(SectorViewer,@working_url.image_url,track,sector)+"\#sector_viewer",:rel=>"nofollow"
+        text " "
+      end
+      pre @image.dump_sector(track,sector)
+      
+    end
+    
+     track_list
+  end
+   def catalog_image     
+
+        image_header
+        
+        div.image_catalog do
+          h2 'all files'
+
+          table.image_catalog {
+            tr {
+              th 'View As'
+              th 'Filename'
+              th 'Type'
+              th 'Length (bytes)'
+              th 'Load Address'
+            }
+            
+            @image.files.length.times do |i|
+              file=@image.files[i]
+              tr {             
+                
+                td {
+                  a "HEX",:href=>R(NativeFile,@working_url.image_url,i)+"?display_mode=hex",:rel=>"nofollow"
+                  [:to_listing,:to_text,:to_picture,:to_screendump].each do |display_mode|                  
+                    if file.respond_to?(display_mode) then
+                      text " | "
+                      description=display_mode.to_s.sub("to_","").upcase
+                      a description,:href=>R(NativeFile,@working_url.image_url,i)+"?display_mode=#{display_mode.to_s}"
+                    end
+                  end
+                  }
+                td file.filename
+                td file.type_description
+                td "$%04X" % file.contents.length
+                td "$%04X" % file.load_address
+              }
+            end
+          }
+        end unless @image.files.length==0
+        track_list
+   end
+
+  def header
+     h1.header do
+      a :href=>'/' do
+        img :src=>'/static/peekbot.png', :height=>130, :width=>229
+      end
+    end    
+    nav_bar
+  end
+
+  def footer
+     p.footer do       
+       text 'peekbot '
+       a "version #{RipXplore::VERSION}" , :href=>'/version_info'
+       text ' powered by '
+       a 'ripxplore',:href=>'http://ripxplore.rubyforge.org/'
+       text ', '
+       a 'camping',:href=>'http://code.whytheluckystiff.net/camping/'
+       text ' & '
+       a 'ruby',:href=>'http://www.ruby-lang.org/'
+       i {
+        text "(last updated:#{LAST_PEEKBOT_UPDATE} : "
+        a 'change log',:href=>'/static/changes.txt'
+        text ")"
+       }
+       br 
+       text 'whipped up by '
+       a 'jonno',:href=>'http://blog.jamtronix.com/'
+       text ' at '
+       a 'jamtronix dot com',:href=>'http://www.jamtronix.com/'
+      br
+      br
+      text "want to"
+      a "help build peekbot?" , :href=>'/help_wanted/'
+        
+   end
+  end
+
+  
+  def version_info
+    table {
+      tr {
+        td 'RipXplore Version' 
+        td RipXplore::VERSION
+      }    
+      tr {
+        td 'Image Format File Extensions' 
+        td ImageFormat.all_possible_extensions.join(", ")
+      }
+      
+        tr {
+        td 'File Systems' 
+        td FileSystem.all_file_systems.join(", ")
+      }
+      
+      tr {
+        td 'Native File Types' 
+        td NativeFileType.all_native_file_types.join(", ")
+      }
+    }
+  end
+  
+  def help_wanted
+    h1 "help wanted!"
+    text "peekbot is very much a work in progress. I am putting this version out 
+    now as a 'proof of concept', and to see if anyone finds it intersting 
+    enough to help work on it. "
+    br
+    br
+    text "Areas where assistance would be most valuable:"
+    br
+    br
+    text" 1) web design. peekbot uses camping, with markaby + css for layout, so 
+    hopefully someone with css chops could make it look much slicker 
+    without too much effort. I'm sure the UI and navigation could be much 
+    improved as well - I am a humble backend hack so would be very happy 
+    to work with anyone who knew how to make a web app easy to use. "
+    br
+    br
+    text"2) plug-ins for image formats (especially .sdk), file systems, and 
+    native file types. My goal for ripxplore is to have everything in 100% 
+    native ruby for maximum portability, and the framework is convoluted 
+    and not yet well documented, so it's probably a bit early for anyone 
+    but a masochist ruby freak to try writing a plugin unaided, but I 
+    would be happy to work with anyone interested, or else if someone has 
+    some images they'd particularly like to see peekbot interpret, and can 
+    give specs or source code i can convert, that would be great too. 
+    There is a heap of opporunity for the C64 particularly, including 
+    converters to detect various image formats and render as PNG."
+    br
+    br
+    text"3) documentation - how to use the website, how to use ripxplore for 
+    specialised conversion and extraction tasks & how to write a plugin."
+    br
+    br
+    text"If you are interested in any of the above, contact me vie email at jonno at jamtronix dot com"
+end
+end
+
+if __FILE__ == $0 then
+  #run from command line
+  port=6502
+  require 'mongrel'
+  require 'mongrel/camping'
+  begin
+  config = Mongrel::Configurator.new  do
+      listener :port => port do
+          uri "/", :handler => Mongrel::Camping::CampingHandler.new(PeekBot)
+          trap("INT") { stop }
+          run
+      end
+    end 
+    puts "** peekbot is running at http://localhost:#{port}/"
+    config.join
+  rescue Errno::EADDRINUSE
+    puts "** ERROR : port #{port} in use - is peekbot already running?"
+  end
+
+end
+

data/peekbot_helper.rb

@@ -0,0 +1,153 @@
+
+lib_path=File.expand_path(File.dirname(__FILE__)+"//..//ripxplore//lib")
+$:.unshift(lib_path) unless $:.include?(lib_path)
+
+require 'RipXplore'
+require 'hpricot'
+require 'open-uri'
+
+WEB_PAGE_EXTENSIONS=['.html','.htm','.php','.asp','.aspx']
+class PeekBotHelper
+  def PeekBotHelper.get_archive_contents(archive_url)
+    
+    images=[]
+    directories=[]
+    other_files=[]
+    if (url_is_website?(archive_url)) then
+      path=URI.split(archive_url)[5]
+      directories<<'../' unless (path=="" || path=='/')
+      html=get_url(archive_url)
+      doc=Hpricot(html)
+      doc.search("a[@href]").each do |a|
+        href=a.attributes["href"]
+        href.sub!("/index.html","/")
+        next if href=~/:/ #skip anything that has a colon - we only want relative URLs
+        next if href=~/#/ #skip anything that has a hash - we don't want anchored links
+        next if href=~/\?/ #skip anything thats a query
+        next if href=~/^\.+$/ #skip . and ..
+        if (href=~/\w\/$/)  || WEB_PAGE_EXTENSIONS.include?(File.extname(href))
+#          if !(href=~/^\//) then 	#directories end with a /, but skip absolute paths
+            
+            directories<<(href)
+#          end
+        else 
+          if FileSystemImage.is_file_system_image_filename?(href) then
+            images<<href 
+          else
+            other_files<<href unless href=~/\/$/
+          end
+        end
+      end  
+    elsif (url_is_ftpsite?(archive_url)) then
+      
+      require 'net/ftp'
+      require 'uri'    
+      ftp_uri=URI.parse(archive_url)
+      partial_path="/"
+      ftp_uri.path.split("/").each do |p|
+        next if p.length<1
+        directories<<partial_path 
+        partial_path+=(p+"/") 
+      end
+      ftp=Net::FTP.new(ftp_uri.host)
+      ftp.login(ftp_uri.user.nil? ? 'anonymous': ftp_uri.user,ftp_uri.password)
+      ftp.nlst(URI.unescape(ftp_uri.path)).each do |f|
+        #yes this is a horrible hack - assume that filenames with a . are files, if no dot then assume it's a directory
+        if f=~/\./ then
+          if  FileSystemImage.is_file_system_image_filename?(f) then
+            images<<f 
+          else
+            other_files<<f
+          end
+        else
+          f="/"+f unless f=~/\// #if we are at the root directory, make sure all paths start with a /
+          directories<<f
+        end
+      end
+      ftp.quit
+    else  #assume it's a local file
+      dirname=PeekBotHelper.file_url_to_pathname(archive_url)
+      dirname+=File::Separator unless dirname=~/#{File::Separator}$/
+#       "stripped #{archive_url} to #{dirname}"
+      Dir.foreach(dirname) do |filename|
+        next if filename=="."
+        images<<filename if FileSystemImage.is_file_system_image_filename?(filename) 
+        full_dir_path=file_url_to_pathname(combine_url("#{dirname}",filename))
+        directories<<filename if FileTest.directory?(full_dir_path) 
+      end
+    end
+    [images.sort,directories.sort,other_files.sort]
+  end
+  
+  @@url_cache={}  
+  def PeekBotHelper.get_url(url)    
+    if @@url_cache[url].nil? then
+      @@url_cache[url]=open(url).read
+    end
+    @@url_cache[url]
+  end
+
+  def PeekBotHelper.url_is_website?(url)
+    url=~/^http[s]?:/ ?true : false
+  end
+  
+  def PeekBotHelper.url_is_ftpsite?(url)
+    url=~/^ftp?:/ ?true : false
+  end
+  
+  def PeekBotHelper.url_is_local_file?(url)
+    return true if (url=~/^file:/ ) || (url=~/^[^\/]*\\/ ) || (url[1].chr==':') || (url[0].chr==File::Separator)
+    false
+  end
+  
+  def PeekBotHelper.file_url_to_pathname(url)
+    pathname=URI.unescape(url.sub(/file:\/+/,""))
+#    puts pathname
+#    puts pathname[1].chr
+    pathname="#{File::Separator}#{pathname}" unless ((pathname[1].chr==':') || (pathname[0].chr==File::Separator))
+    pathname
+  end
+  def PeekBotHelper.combine_url(first_url,second_url)
+    
+    # URI::FTP.join seems broken (complains about missing typcode) so here's a horrible hacky replacement
+#    puts "joining #{first_url},#{second_url}"  
+    if url_is_ftpsite?(first_url) then
+      ftp_uri=URI.parse(first_url)
+      result=URI::FTP.new('ftp',
+               "#{ftp_uri.user}:#{ftp_uri.password}", 
+               ftp_uri.host, ftp_uri.port, nil, 
+              second_url,
+               nil, nil,nil).to_s.sub("//:@","//")
+    elsif url_is_local_file?(first_url) then
+      dir_path=PeekBotHelper.file_url_to_pathname(first_url)
+      result="file://#{File.expand_path(second_url,dir_path)}"
+    else      
+      result=URI.join(first_url,second_url)
+    end
+#    puts "RESULT: #{result}"
+    result
+  end
+end
+
+class WorkingUrl
+    attr_accessor :archive_url,:image_url
+    def initialize(archive_url=nil,image_url=nil)
+      #when running under Apache + mod_rewrite, the second / in http:// is getting stripped, so add it back in if necessary
+      @archive_url=archive_url.sub(/:\/([^\/])/,'://\1').gsub(' ','%20').gsub('#','%23').gsub('[','%5B').gsub(']','%5D') unless archive_url.nil?
+      @image_url=image_url.sub(/:\/([^\/])/,'://\1').gsub(' ','%20').gsub('#','%23').gsub('[','%5B').gsub(']','%5D') unless image_url.nil?
+    end
+    
+    def image_basename
+      if image_url.nil? then
+        nil
+      else
+        URI.unescape(File.basename(image_url))
+      end
+    end          
+    
+    
+    def WorkingUrl.split_image_url_into_parts(url)      
+      return WorkingUrl.new(File.dirname(url)+"/",url)
+    end
+  end
+  

data/static/changes.txt

@@ -0,0 +1,56 @@
+PEEKBOT CHANGE LOG
+
+2008-12-14
+* initial support for ZX81
+
+2008-12-13
+* low-res Coco pictures
+
+2008-12-07
+* detokenise TI 99/4a BASIC files
+
+2008-12-05
+* eliminate timeout (500 camping error) the first time a random picture/text/listing was viewed when app restarted
+
+2008-11-30
+* added 'screendump' feature
+
+2008-11-29
+* now caches PNG & GIF files (rather than re-extracting from image on each view)
+* added random text and listing feature
+
+2008-11-28
+* added RLE support
+
+2008-11-25
+* added GIF support
+
+2008-11-25
+* 'All Pictures'  & 'All Texts' views
+* Random Picture page
+
+2008-11-24
+* Apple 2 hires picture improvements
+
+2008-11-21
+* added support for Tandy Color Computer files (Tim Lindner)
+
+2008-11-15
+* fixed some TI 99/4a file system bugs
+* added support for TI Artist images
+
+
+2008-11-14
+* added 'help wanted' page
+* added support for FTP archives
+* added link to TI 99/4a archive at ftp.whtech.com
+* partial support for TI 99/4a formats
+
+2008-11-13
+* removed listing (disassembly) of binary files 
+* removed links to Apple 2 archives that aren't mainly DSK files
+* made peekbot logo in page header clickable
+* links to hex dumps now marked 'rel=nofollow' (no point getting a hex dump into google)
+
+2008-11-09
+* first public version

data/static/style.css

@@ -0,0 +1,67 @@
+body { background-color: #cde; color: #333; }
+
+body, p, ol, ul, td, th {
+  font-family: verdana, arial, helvetica, sans-serif;
+  font-size:   22px;
+  line-height: 28px;
+}
+
+pre {
+  background-color: #eee;
+  padding: 10px;
+  font-size: 16px;
+  white-space: pre-wrap; /* css-3 */
+  white-space: -moz-pre-wrap !important; /* Mozilla, since 1999 */
+  white-space: -pre-wrap; /* Opera 4-6 */
+  white-space: -o-pre-wrap; /* Opera 7 */
+  word-wrap: break-word; /* Internet Explorer 5.5+ */
+
+}
+
+
+td,th {
+  padding-left: 10px;
+  padding-right: 10px;
+}
+
+tr.header {
+  background-color: #aaf;
+}
+pre.hex_dump {
+  background-color: #aaf;
+}
+
+p.footer {
+  font-size:   12px;
+  line-height: 16px;
+}
+
+h2 {
+	background-color: #bcd;
+}
+
+h3 {
+	background-color: #bcd;
+}
+
+img {
+	border: 0px;
+}
+
+li.directory {
+	background-color: #89a;
+}
+
+li.image {
+	background-color: #9ab;
+}
+
+li.other_file {
+	background-color: #abc;
+}
+
+a { color: #000; }
+a:visited { color: #666; }
+a:hover { color: #fff; background-color:#000; }
+
+

metadata

@@ -0,0 +1,92 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.4
+specification_version: 1
+name: peekbot
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+date: 2008-12-20 00:00:00 +11:00
+summary: a web app that allows browsing of disk images as used by vintage computer emulators
+require_paths: 
+- lib
+email: jonno@jamtronix.com
+homepage: http://peekbot.rubyforge.org
+rubyforge_project: 
+description: 
+autorequire: 
+default_executable: 
+bindir: .
+has_rdoc: false
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: 
+- Jonno Downes
+files: 
+- ./dispatch.fcgi
+- ./m.bat
+- ./make_all_images.rb
+- ./peekbot.rb
+- ./peekbot_helper.rb
+- ./static
+- ./static/changes.txt
+- ./static/peekbot.png
+- ./static/style.css
+- static/changes.txt
+- static/peekbot.png
+- static/style.css
+test_files: []
+
+rdoc_options: []
+
+extra_rdoc_files: []
+
+executables: 
+- peekbot.rb
+extensions: []
+
+requirements: []
+
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: hpricot
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Version::Requirement 
+    requirements: 
+    - - ">"
+      - !ruby/object:Gem::Version 
+        version: 0.0.0
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: ripxplore
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Version::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.0.3
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: camping
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Version::Requirement 
+    requirements: 
+    - - ">"
+      - !ruby/object:Gem::Version 
+        version: 0.0.0
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: mongrel
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Version::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.3.10
+    version: