gopher2000 0.2.2 → 0.5.5

data/lib/gopher2000/dsl.rb

@@ -81,7 +81,7 @@ module Gopher
     end
 
     # watch the specified script for changes
-    # @param [String] script to watch
+    # @param [String] f script to watch
     def watch(f)
       application.scripts << f
     end

data/lib/gopher2000/handlers/directory_handler.rb

@@ -27,7 +27,7 @@ module Gopher
 
       #
       # strip slashes, extra dots, etc, from an incoming selector and turn it into a 'normalized' path
-      # @param [String] path
+      # @param [String] p path to check
       # @return clean path string
       #
       def sanitize(p)
@@ -65,12 +65,10 @@ module Gopher
       #
       # handle a request
       #
-      # @param [Hash] the params as parsed during the dispatching process - the main thing here should be :splat, which will basically be the path requested.
-      # @param [Request] - the Request object for this session -- not currently used?
+      # @param [Hash] params the params as parsed during the dispatching process - the main thing here should be :splat, which will basically be the path requested.
+      # @param [Request] request the Request object for this session -- not currently used?
       #
       def call(params = {}, request = nil)
-#        debug_log "DirectoryHandler: call #{params.inspect}, #{request.inspect}"
-
         lookup = request_path(params)
 
         raise Gopher::InvalidRequest if ! contained?(lookup)
@@ -86,7 +84,7 @@ module Gopher
 
       #
       # generate a directory listing
-      # @param [String] path to directory
+      # @param [String] dir path to directory
       # @return rendered directory output for a response
       #
       def directory(dir)
@@ -98,7 +96,7 @@ module Gopher
         # iterate through the contents of this directory.
         # NOTE: we don't filter this, so we will ALWAYS list subdirectories of a mounted folder
         #
-        Dir.glob("#{dir}/*.*").each do |x|
+        Dir.glob("#{dir}/*").each do |x|
           # if this is a directory, then generate a directory link for it
           if File.directory?(x)
             m.directory File.basename(x), to_selector(x), @application.host, @application.port

data/lib/gopher2000/rendering/base.rb

@@ -5,10 +5,14 @@ module Gopher
   #
   module Rendering
 
+    require 'artii'
+
     # "A CR LF denotes the end of the item." RFC 1436
     # @see http://www.faqs.org/rfcs/rfc1436.html
     LINE_ENDING = "\r\n"
 
+    DEFAULT_ENCODING = 'UTF-8'
+    
     #
     # base class for rendering output. this class provides methods
     # that can be used when rendering both text and gopher menus
@@ -40,7 +44,7 @@ module Gopher
       #   then adds any required spacing
       #
       def text(text)
-        self << text
+        self << text.force_encoding(DEFAULT_ENCODING)
         add_spacing
       end
 
@@ -94,6 +98,32 @@ module Gopher
         self.to_s
       end
 
+      #
+      # output a figlet, which is a big ASCII art header like this:
+      #    _    _      _ _       _
+      #   | |  | |    | | |     | |
+      #   | |__| | ___| | | ___ | |
+      #   |  __  |/ _ \ | |/ _ \| |
+      #   | |  | |  __/ | | (_) |_|
+      #   |_|  |_|\___|_|_|\___/(_)
+      #
+      # This method doesn't do any width checks, so you should be
+      # careful with it.
+      # You can get a list of fonts from the artii source code or
+      # http://www.figlet.org/examples.html
+      # https://github.com/miketierney/artii/tree/master/lib/figlet/fonts
+      
+      # @param [String] str the text you want to use for your figlet
+      # @param [String] font name of the font. Defaults to 'big'.
+      #
+      def figlet(str, font = 'big')
+        a = Artii::Base.new(:font => font)
+        a.asciify(str).split("\n").each do |l|
+          text l
+        end
+        self.to_s
+      end
+
       #
       # output a centered string with a nice underline below it,
       # centered on the current output width
@@ -119,6 +149,17 @@ module Gopher
         underline(@width, under)
       end
 
+      #
+      # output a 'small' header, just the text with an underline
+      # @param [String] str - the string to output
+      # @param [String] under - the desired underline character
+      #
+      def small_header(str, under = '=')
+        str = " " + str + " "
+        text(str)
+        underline(str.length, under)
+      end
+
       #
       # output a centered string in a box
       # @param [String] str the string to output

data/lib/gopher2000/rendering/menu.rb

@@ -1,5 +1,7 @@
 module Gopher
   module Rendering
+    require 'mimemagic'
+
     #
     # The MenuContext is for rendering gopher menus in the "pseudo
     # file-system hierarchy" defined by RFC1436
@@ -7,7 +9,6 @@ module Gopher
     # @see http://www.ietf.org/rfc/rfc1436.txt
     #
     class Menu < Base
-
       # default host value when rendering a line with no selector
       NO_HOST = '(FALSE)'
 
@@ -15,7 +16,7 @@ module Gopher
       NO_PORT = 0
 
       # Sanitizes text for use in gopher menus
-      # @param [String] text text to cleanup
+      # @param [String] raw text to cleanup
       # @return string that can be used in a gopher menu
       def sanitize_text(raw)
         raw.
@@ -92,11 +93,51 @@ module Gopher
       #   method instead
       # @param [String] host for link, defaults to current host
       # @param [String] port for link, defaults to current port
-      def link(text, selector, host=nil, port=nil)
-        type = determine_type(selector)
+      # @param [String] real filepath of the link
+      # @param [String] selector type. if not specified, we will guess
+      def link(text, selector, host=nil, port=nil, filepath=nil, type=nil)
+        if !type
+          if filepath
+            type = determine_type(filepath)
+          else
+            type = determine_type(selector)
+          end
+        end
         line type, text, selector, host, port
       end
 
+      #
+      # output a link to text output
+      #
+      # @param [String] text the text of the link
+      # @param [String] selector the path of the link. the extension of this path will be used to
+      #   detemine the type of link -- image, archive, etc. If you want
+      #   to specify a specific link-type, you should use the text
+      #   method instead
+      # @param [String] host for link, defaults to current host
+      # @param [String] port for link, defaults to current port
+      # @param [String] real filepath of the link
+      def text_link(text, selector, host=nil, port=nil, filepath=nil)
+        link(text, selector, host, port, filepath, '0')
+      end
+      
+      # Create an HTTP link entry. This is how this works (via wikipedia)
+      #
+      # For example, to create a link to http://gopher.quux.org/, the
+      # item type is "h", the display string is the title of the link,
+      # the item selector is "URL:http://gopher.quux.org/", and the
+      # domain and port are that of the originating Gopher server (so
+      # that clients that do not support URL links will query the
+      # server and receive an HTML redirection page).
+      #
+      # @param [String] text the text of the link
+      # @param [String] URL of the link
+      # @param [String] host for link, defaults to current host
+      # @param [String] port for link, defaults to current port
+      def http(text, url, host=nil, port=nil)
+        line "h", text, "URL:#{url}", host, port
+      end
+      
       #
       # output a search entry
       # @param [String] text the text of the link
@@ -109,19 +150,67 @@ module Gopher
 
       #
       # Determines the gopher type for +selector+ based on the
-      # extension. This is a pretty simple check based on the entities
-      # list in http://www.ietf.org/rfc/rfc1436.txt
-      # @param [String] selector, presumably a link to a file name with an extension
+      # information stored in the shared mime database.
+      # @param [String] filepath The full path to the file (should also exist, if possible)
       # @return gopher selector type
       #
-      def determine_type(selector)
-        ext = File.extname(selector).downcase
-        case ext
-        when '.zip', '.gz', '.bz2' then '5'
-        when '.gif' then 'g'
-        when '.jpg', '.png' then 'I'
-        when '.mp3', '.wav' then 's'
-        else '0'
+      def determine_type(filepath)
+        # Determine MIME type by path
+        mimetype = MimeMagic.by_path(filepath)
+
+        # Determine MIME type by contents
+        if !mimetype
+          begin
+            # Open file
+            file = File.open(filepath)
+
+            # Try to detect MIME type using by recognition of typical characters
+            mimetype = MimeMagic.by_magic(file)
+
+            if !mimetype
+              file.rewind
+
+              # Read up to 1k of file data and look for a "\0\0" sequence (typical for binary files)
+              if file.read(1000).include?("\0\0")
+                mimetype = MimeMagic.new("application/octet-stream")
+              else
+                mimetype = MimeMagic.new("text/plain")
+              end
+              
+              file.close
+            end
+          rescue SystemCallError,IOError
+            nil
+          end
+        end
+
+        if !mimetype
+          ext = File.extname(filepath).split(".").last
+          mimetype = MimeMagic.by_extension(ext)
+        end
+        
+        if !mimetype
+          return '9' # Binary file
+        elsif mimetype.child_of?('application/gzip') || mimetype.child_of?('application/x-bzip') || mimetype.child_of?('application/zip')
+          return '5' # archive
+        elsif mimetype.child_of?('image/gif')
+          return 'g' # GIF image
+        elsif mimetype.child_of?('text/x-uuencode')
+          return '6' # UUEncode encoded file
+        elsif mimetype.child_of?('application/mac-binhex40')
+          return '4' # BinHex encoded file
+        elsif mimetype.child_of?('text/html') || mimetype.child_of?('application/xhtml+xml')
+          return 'h' # HTML file
+        elsif mimetype.mediatype == 'text'    || mimetype.child_of?('text/plain')
+          return '0' # General text file
+        elsif mimetype.mediatype == 'image'
+          return 'I' # General image file
+        elsif mimetype.mediatype == 'audio'
+          return 's' # General audio file
+        elsif mimetype.mediatype == 'video'
+          return 'v' # General video file
+        else
+          return '9' # Binary file
         end
       end
     end

data/lib/gopher2000/request.rb

@@ -7,10 +7,21 @@ module Gopher
     attr_accessor :selector, :input, :ip_address
 
     def initialize(raw, ip_addr=nil)
-      @selector, @input = raw.chomp.split("\t")
-      @ip_address = ip_addr
+      @raw = raw
+      @selector, @input = @raw.chomp.split("\t")
+      
+	    @selector = Gopher::Application.sanitize_selector(@selector)
+	    @ip_address = ip_addr
     end
 
+    def url?
+      @raw =~ /^URL\:/
+    end
+
+    def url
+      @raw.chomp.split("\t").first.gsub(/^URL\:/, '')
+    end
+    
     # confirm that this is actually a valid gopher request
     # @return [Boolean] true if the request is valid, false otherwise
     def valid?

data/lib/gopher2000/server.rb

@@ -8,12 +8,12 @@ module Gopher
 
     #
     # constructor
-    # @param [Application] instance of Gopher::Application we want to run
+    # @param [Application] a instance of Gopher::Application we want to run
     #
     def initialize(a)
       @app = a
     end
-
+ 
     #
     # @return [String] name of the host specified in our config
     #
@@ -28,6 +28,13 @@ module Gopher
       @app.config[:port] ||= 70
     end
 
+    #
+    # @return [String] environment specified in config
+    #
+    def env
+      @app.config[:env] || 'development'
+    end
+    
     #
     # main app loop. called via at_exit block defined in DSL
     #
@@ -77,8 +84,8 @@ module Gopher
       require 'optparse'
       OptionParser.new { |op|
         op.on('-p port',   'set the port (default is 70)')                { |val| set :port, Integer(val) }
-        op.on('-o addr',   'set the host (default is 0.0.0.0)')             { |val| set :bind, val }
-        op.on('-e env',    'set the environment (default is development)')  { |val| set :environment, val.to_sym }
+        op.on('-o addr',   'set the host (default is 0.0.0.0)')             { |val| set :host, val }
+        op.on('-e env',    'set the environment (default is development)')  { |val| set :env, val.to_sym }
       }.parse!(ARGV.dup)
     end
   end

data/lib/gopher2000/version.rb

@@ -1,4 +1,4 @@
 module Gopher
   # current version of the app
-  VERSION = "0.2.2"
+  VERSION = "0.5.5"
 end

data/spec/application_spec.rb

@@ -9,46 +9,46 @@ describe Gopher::Application do
   end
 
   it 'should have default host/port' do
-    @app.host.should == "0.0.0.0"
-    @app.port.should == 70
+    expect(@app.host).to eq("0.0.0.0")
+    expect(@app.port).to eq(70)
   end
 
   describe "should_reload?" do
     it "is false if no scripts" do
-      @app.should_reload?.should == false
+      expect(@app.should_reload?).to eq(false)
     end
 
     it "shouldn't do anything if last_reload not set" do
-      @app.last_reload.should be_nil
+      expect(@app.last_reload).to be_nil
       @app.scripts << "foo.rb"
-      @app.should_reload?.should == false
+      expect(@app.should_reload?).to eq(false)
     end
 
     it "should check script date" do
       now = Time.now
-      Time.stub!(:now).and_return(now)
+      allow(Time).to receive(:now).and_return(now)
 
       @app.last_reload = Time.now - 1000
       @app.scripts << "foo.rb"
-      File.should_receive(:mtime).with("foo.rb").and_return(now)
+      expect(File).to receive(:mtime).with("foo.rb").and_return(now)
 
-      @app.should_reload?.should == true
+      expect(@app.should_reload?).to eq(true)
     end
   end
 
   describe "reload_stale" do
     it "should load script and update last_reload" do
       now = Time.now
-      Time.stub!(:now).and_return(now)
+      allow(Time).to receive(:now).and_return(now)
 
-      @app.should_receive(:should_reload?).and_return(true)
+      expect(@app).to receive(:should_reload?).and_return(true)
 
       @app.last_reload = Time.now - 1000
       @app.scripts << "foo.rb"
-      @app.should_receive(:load).with("foo.rb")
+      expect(@app).to receive(:load).with("foo.rb")
       @app.reload_stale
 
-      @app.last_reload.should == now
+      expect(@app.last_reload).to eq(now)
     end
   end
 end

data/spec/dispatching_spec.rb

@@ -24,7 +24,7 @@ describe Gopher::Application do
       @request = Gopher::Request.new("/about")
 
       keys, block = @server.lookup(@request.selector)
-      keys.should == {}
+      expect(keys).to eq({})
     end
 
     it "should translate path" do
@@ -32,7 +32,7 @@ describe Gopher::Application do
       @request = Gopher::Request.new("/about/x/y")
 
       keys, block = @server.lookup(@request.selector)
-      keys.should == {:foo => 'x', :bar => 'y'}
+      expect(keys).to eq({:foo => 'x', :bar => 'y'})
     end
 
     it "should return default route if no other route found, and default is defined" do
@@ -41,8 +41,8 @@ describe Gopher::Application do
       end
       @request = Gopher::Request.new("/about/x/y")
       @response = @server.dispatch(@request)
-      @response.body.should == "DEFAULT ROUTE"
-      @response.code.should == :success
+      expect(@response.body).to eq("DEFAULT ROUTE")
+      expect(@response.code).to eq(:success)
     end
 
     it "should respond with error if no route found" do
@@ -50,7 +50,8 @@ describe Gopher::Application do
       @request = Gopher::Request.new("/junk/x/y")
 
       @response = @server.dispatch(@request)
-      @response.code.should == :missing
+      expect(@response.code).to eq(:missing)
+      expect(@response.body).to contain_any_error
     end
 
     it "should respond with error if invalid request" do
@@ -58,7 +59,8 @@ describe Gopher::Application do
       @request = Gopher::Request.new("x" * 256)
 
       @response = @server.dispatch(@request)
-      @response.code.should == :error
+      expect(@response.code).to eq(:error)
+      expect(@response.body).to contain_any_error
     end
 
     it "should respond with error if there's an exception" do
@@ -66,7 +68,8 @@ describe Gopher::Application do
       @request = Gopher::Request.new("/x")
 
       @response = @server.dispatch(@request)
-      @response.code.should == :error
+      expect(@response.code).to eq(:error)
+      expect(@response.body).to contain_any_error
     end
   end
 
@@ -82,7 +85,7 @@ describe Gopher::Application do
 
     it "should run the block" do
       @response = @server.dispatch(@request)
-      @response.body.should == "GOPHERTRON"
+      expect(@response.body).to eq("GOPHERTRON")
     end
   end
 
@@ -97,37 +100,47 @@ describe Gopher::Application do
 
     it "should use incoming params" do
       @response = @server.dispatch(@request)
-      @response.body.should == "x/a/y/b"
+      expect(@response.body).to eq("x/a/y/b")
     end
   end
 
   describe "dispatch to mount" do
     before(:each) do
-      @h = mock(Gopher::Handlers::DirectoryHandler)
-      @h.should_receive(:application=).with(@server)
-      Gopher::Handlers::DirectoryHandler.should_receive(:new).with({:bar => :baz, :mount_point => "/foo"}).and_return(@h)
+      @h = double(Gopher::Handlers::DirectoryHandler)
+      expect(@h).to receive(:application=).with(@server)
+      expect(Gopher::Handlers::DirectoryHandler).to receive(:new).with({:bar => :baz, :mount_point => "/foo"}).and_return(@h)
 
       @server.mount "/foo", :bar => :baz
     end
 
     it "should work for root path" do
       @request = Gopher::Request.new("/foo")
-      @h.should_receive(:call).with({:splat => ""}, @request)
+      expect(@h).to receive(:call).with({:splat => ""}, @request)
 
       @response = @server.dispatch(@request)
-      @response.code.should == :success
+      expect(@response.code).to eq(:success)
     end
 
     it "should work for subdir" do
       @request = Gopher::Request.new("/foo/bar")
-      @h.should_receive(:call).with({:splat => "bar"}, @request)
+      expect(@h).to receive(:call).with({:splat => "bar"}, @request)
 
       @response = @server.dispatch(@request)
-      @response.code.should == :success
+      expect(@response.code).to eq(:success)
     end
   end
 
+  describe 'dispatch for URL requests' do
+    let(:target) { 'URL:http://github.com/muffinista/gopher2000' }
+    let(:request) { Gopher::Request.new(target) }
+    let(:response) { @server.dispatch(request) }
 
+    it "should return web page" do
+      expect(response.body).to include('<meta http-equiv="refresh" content="5;URL=http://github.com/muffinista/gopher2000">')
+    end
+  end
+
+  
   describe "globs" do
     before(:each) do
       @server.route '/about/*' do
@@ -138,7 +151,15 @@ describe Gopher::Application do
     it "should put wildcard into param[:splat]" do
       @request = Gopher::Request.new("/about/a/b")
       @response = @server.dispatch(@request)
-      @response.body.should == "a/b"
+      expect(@response.body).to eq("a/b")
+    end
+  end
+end
+
+RSpec::Matchers.define :contain_any_error do
+  match do |actual|
+    actual.split(/\r?\n/).any? do |line| 
+      line.match(/^3.*?\tnull\t\(FALSE\)\t0$/)
     end
   end
 end