gopher2000 0.4.0 → 0.5.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 6c507fab7aaa1412d98ac4a18870fe786098aa9aa4e393bd1204cc476f111dfb
+  data.tar.gz: e767f8ea12042fc19a7c6f6fc25766b3d91838f053abf1abe97b17b8c99da4e5
+SHA512:
+  metadata.gz: 3497713e468d3d6eefecafcb68cc7421c8af9db40bcd0e30c865f54e1a8a0e8ab0a8098fa8f5369a518cf4dfd391612ba3ada0d4a4ba51b17240934fa500275d
+  data.tar.gz: 89145000523a7d3d7c77ebad777a0421211b05edfe973c4bc3cbe45ea37d2541bfd773be0ed2c86cf114a0a6c47c1fa6a8e64b2ab76e9a8d278423d5b19cb80b

data/.ruby-version

@@ -0,0 +1 @@
+2.6.3

data/.travis.yml

@@ -0,0 +1,8 @@
+language: ruby
+rvm:
+  - 2.0.0
+  - 2.1.1
+  - 2.3.3
+  - 2.4.2
+  # uncomment this line if your project needs to run something other than `rake`:
+# script: bundle exec rspec spec

data/Gemfile

@@ -1,6 +1,4 @@
-source "http://rubygems.org"
-
-# Specify your gem's dependencies in gopher.gemspec
+source 'https://rubygems.org'
 gemspec
 
 gem "rake"
@@ -8,19 +6,7 @@ gem "rake"
 # Add dependencies to develop your gem here.
 # Include everything needed to run rake, tests, features, etc.
 group :development do
-  gem 'simplecov', :require => false, :group => :test
-
-  gem "shoulda", ">= 0"
-  gem "rspec"
-
-  gem "bundler", "~> 1.0.0"
-  gem "watchr"
 
   # There's a god example script stashed away in the repo
   gem "god"
-
-  #
-  # gems used in examples and for development.
-  #
-  gem "weather-underground"
 end

data/README.markdown

@@ -16,6 +16,8 @@ Gopher2000 - A Gopher server for the next millenium
 Gopher2000 is a ruby-based Gopher server. It is built for speedy, enjoyable development of
 all sorts of gopher sites.
 
+[![Build Status](https://travis-ci.org/muffinista/gopher2000.svg?branch=master)](https://travis-ci.org/muffinista/gopher2000)
+
 Features
 --------
 * Simple, Sintra-inspired routing DSL.

data/gopher2000.gemspec

@@ -12,7 +12,6 @@ Gem::Specification.new do |s|
   s.summary     = %q{Gopher2000 - A Gopher server for the next millenium}
   s.description = %q{Gopher2000 is a ruby-based Gopher server. It is built for speedy, enjoyable development of all sorts of gopher sites.}
 
-  s.rubyforge_project = "gopher2000"
   s.licenses = ["WTFPL"]
 
   s.files         = `git ls-files`.split("\n")
@@ -26,11 +25,11 @@ Gem::Specification.new do |s|
   s.add_development_dependency "yard"
   s.add_development_dependency "shoulda"
   s.add_development_dependency "rdoc"
-  s.add_development_dependency "simplecov"
+  s.add_development_dependency "simplecov", "~> 0.16.1"
   s.add_development_dependency "watchr"
-  s.add_development_dependency "eventmachine"
 
   s.add_runtime_dependency "artii", ">= 2.0.1"
-  s.add_runtime_dependency "eventmachine"
+  s.add_runtime_dependency "eventmachine", "~> 1.2.5"
   s.add_runtime_dependency "logging"
+  s.add_runtime_dependency "mimemagic"
 end

data/lib/gopher2000/base.rb

@@ -385,7 +385,7 @@ module Gopher
     # Gopher servers in production)
     #
     def non_blocking?
-      config[:non_blocking] ||= ! debug_mode?
+      config.key?(:non_blocking) ? config[:non_blocking] : ! debug_mode?
     end
 
 

data/lib/gopher2000/dispatcher.rb

@@ -25,10 +25,19 @@ module Gopher
     # @param [String] selector incoming selector
     # @return Response object
     #
-    def receive_data(selector)
-      call! Request.new(selector, remote_ip)
+    def receive_data data
+      (@buf ||= '') << data
+      
+      while line = @buf.slice!(/(.*)\r?\n/)
+        receive_line(line)
+      end
     end
 
+    # Invoked with lines received over the network
+    def receive_line(line)
+      call! Request.new(line, remote_ip)
+    end
+    
     #
     # generate a request object from an incoming selector, and dispatch it to the app
     # @param [Request] request Request object to handle

data/lib/gopher2000/handlers/directory_handler.rb

@@ -96,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,12 +5,14 @@ module Gopher
   #
   module Rendering
 
-	require 'artii'
+    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
@@ -42,7 +44,7 @@ module Gopher
       #   then adds any required spacing
       #
       def text(text)
-        self << text
+        self << text.force_encoding(DEFAULT_ENCODING)
         add_spacing
       end
 
@@ -96,31 +98,31 @@ 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 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,
@@ -147,16 +149,16 @@ module Gopher
         underline(@width, under)
       end
 
-	  #
-	  # output a 'small' header, just the text with an underline
+      #
+      # 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
+      #
+      def small_header(str, under = '=')
+        str = " " + str + " "
+        text(str)
+        underline(str.length, under)
+      end
 
       #
       # output a centered string in a box

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)'
 
@@ -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/version.rb

@@ -1,4 +1,4 @@
 module Gopher
   # current version of the app
-  VERSION = "0.4.0"
+  VERSION = "0.5.3"
 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