gopher2000 0.1.0

data/lib/gopher2000/dsl.rb

@@ -0,0 +1,128 @@
+require File.join(File.dirname(__FILE__), '..', 'gopher2000')
+
+module Gopher
+  #
+  # DSL that can be used to specify gopher apps with a very simple format.
+  # @see the examples/ directory for working scripts
+  #
+  module DSL
+    @application = nil
+
+    #
+    # initialize an instance of an Application if we haven't already, otherwise, return
+    #   the current app
+    # @return [Gopher::Application] current app
+    #
+    def application
+      return @application unless @application.nil?
+
+      @application = Gopher::Application.new
+      @application.reset!
+    end
+
+    # set a config value
+    # @param [Symbol] key key to add to config
+    # @param [String] value value to set
+    def set(key, value = nil)
+      application.config[key] = value
+    end
+
+    # specify a route
+    # @param [String] path path of the route
+    # @yield block that will respond to the request
+    def route(path, &block)
+      application.route(path, &block)
+    end
+
+    # specify a default route
+    def default_route(&block)
+      application.default_route(&block)
+    end
+
+    # mount a folder for browsing
+    def mount(path, opts = {})
+      route, folder = path.first
+
+      #
+      # if path has more than the one option (:route => :folder),
+      # then incorporate the rest of the hash into our opts
+      #
+      if path.size > 1
+        other_opts = path.dup
+        other_opts.delete(route)
+        opts = opts.merge(other_opts)
+      end
+
+      application.mount(route, opts.merge({:path => folder}))
+    end
+
+    # specify a menu template
+    # @param [Symbol] name of the template
+    # @yield block which renders the template
+    def menu(name, &block)
+      application.menu(name, &block)
+    end
+
+    # specify a text template
+    # @param [Symbol] name of the template
+    # @yield block which renders the template
+    def text(name, &block)
+      application.text(name, &block)
+    end
+
+#    def template(name, &block)
+#      application.template(name, &block)
+#    end
+
+    # specify some helpers for your app
+    # @yield block which defines the helper methods
+    def helpers(&block)
+      application.helpers(&block)
+    end
+
+    # watch the specified script for changes
+    # @param [String] script to watch
+    def watch(f)
+      application.scripts << f
+    end
+
+    #
+    # run a script with the specified options applied to the config. This is
+    #   called by bin/gopher2000
+    # @param [String] script path to script to run
+    # @param [Hash] opts options to pass to script. these will override any
+    #   config options specified in the script, so you can use this to
+    #   run on a different host/port, etc.
+    #
+    def run(script, opts = {})
+
+      load script
+
+      #
+      # apply options after loading the script so that anything specified on the command-line
+      # will take precedence over defaults specified in the script
+      #
+      opts.each { |k, v|
+        set k, v
+      }
+
+      if application.config[:debug] == true
+        puts "watching #{script} for changes"
+        watch script
+      end
+
+    end
+  end
+end
+
+include Gopher::DSL
+
+#
+# don't call at_exit if we're running specs
+#
+unless ENV['gopher_test']
+  at_exit do
+    s = Gopher::Server.new(@application)
+    s.run!
+  end
+end

data/lib/gopher2000/errors.rb

@@ -0,0 +1,14 @@
+module Gopher
+
+  # base error class
+  class GopherError < StandardError; end
+
+  # When a selector isn't found in the route map
+  class NotFoundError < GopherError; end
+
+  # Invalid gopher requests
+  class InvalidRequest < GopherError; end
+
+  # Template not found in local or global space
+  class TemplateNotFound < GopherError; end
+end

data/lib/gopher2000/handlers/base_handler.rb

@@ -0,0 +1,18 @@
+module Gopher
+
+  #
+  # namespace for custom handlers
+  #
+  module Handlers
+    #
+    # Base class for custom request handlers.  Any custom handler
+    # code should inherit from this class.
+    #
+    class BaseHandler
+      attr_accessor :application
+
+      # include rendering here so that Menu/Text renderers are available to any handlers
+      include Rendering
+    end
+  end
+end

data/lib/gopher2000/handlers/directory_handler.rb

@@ -0,0 +1,125 @@
+require 'pathname'
+
+module Gopher
+  module Handlers
+    #
+    # handle browsing a directory structure/returning files to the client
+    #
+    class DirectoryHandler < BaseHandler
+
+      attr_accessor :path, :filter, :mount_point
+
+      #
+      # @option opts [String] :filter a subset of files to show to user
+      # @option opts [String] :path the base path of the filesystem to work from
+      # @option opts [String] :mount_point the route for this handler -- this will be used to generate paths in the response
+      #
+      def initialize(opts = {})
+        opts = {
+          :filter => "*.*",
+          :path => Dir.getwd
+        }.merge(opts)
+
+        @path = opts[:path]
+        @filter = opts[:filter]
+        @mount_point = opts[:mount_point]
+      end
+
+      #
+      # strip slashes, extra dots, etc, from an incoming selector and turn it into a 'normalized' path
+      # @param [String] path
+      # @return clean path string
+      #
+      def sanitize(p)
+        Pathname.new(p).cleanpath.to_s
+      end
+
+      #
+      # make sure that the requested file is actually contained within our mount point. this
+      # prevents requests like the below from working:
+      #
+      # echo "/files/../../../../../tmp/foo" | nc localhost 7070
+      #
+      def contained?(p)
+        (p =~ /^#{@path}/) != nil
+      end
+
+      #
+      # take the incoming parameters, and turn them into a path
+      # @option opts [String] :splat splat value from Request params
+      #
+      def request_path(params)
+        File.absolute_path(sanitize(params[:splat]), @path)
+      end
+
+      #
+      # take the path to a file and turn it into a selector which will match up when
+      # a gopher client makes requests
+      # @param [String] path to a file on the filesytem
+      # @return selector which will match the file on subsequent requests
+      #
+      def to_selector(path)
+        path.gsub(/^#{@path}/, @mount_point)
+      end
+
+      #
+      # 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?
+      #
+      def call(params = {}, request = nil)
+#        debug_log "DirectoryHandler: call #{params.inspect}, #{request.inspect}"
+
+        lookup = request_path(params)
+
+        raise Gopher::InvalidRequest if ! contained?(lookup)
+
+        if File.directory?(lookup)
+          directory(lookup)
+        elsif File.file?(lookup)
+          file(lookup)
+        else
+          raise Gopher::NotFoundError
+        end
+      end
+
+      #
+      # generate a directory listing
+      # @param [String] path to directory
+      # @return rendered directory output for a response
+      #
+      def directory(dir)
+        m = Menu.new(@application)
+
+        m.text "Browsing: #{dir}"
+
+        #
+        # 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|
+          # 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
+
+          elsif File.file?(x) && File.fnmatch(filter, x)
+            # fnmatch makes sure that the file matches the glob filter specified in the mount directive
+
+            # otherwise, it's a normal file link
+            m.link File.basename(x), to_selector(x), @application.host, @application.port
+          end
+        end
+        m.to_s
+      end
+
+      #
+      # return a file handle -- Connection will take this and send it back to the client
+      #
+      def file(f)
+        File.new(f)
+      end
+
+    end
+  end
+end

data/lib/gopher2000/rendering/abstract_renderer.rb

@@ -0,0 +1,10 @@
+module Gopher
+  module Rendering
+    #
+    # Abstract class for rendering. This is basically overkill right now, so..
+    # @todo consider refactoring out
+    #
+    class AbstractRenderer
+    end
+  end
+end

data/lib/gopher2000/rendering/base.rb

@@ -0,0 +1,174 @@
+module Gopher
+
+  #
+  # namespace for classes that render output for the app
+  #
+  module Rendering
+
+    # "A CR LF denotes the end of the item." RFC 1436
+    # @see http://www.faqs.org/rfcs/rfc1436.html
+    LINE_ENDING = "\r\n"
+
+    #
+    # base class for rendering output. this class provides methods
+    # that can be used when rendering both text and gopher menus
+    #
+    class Base < AbstractRenderer
+      attr_accessor :result, :spacing, :width, :request, :params, :application
+
+      def initialize(app=nil)
+        @application = app
+        @result = ""
+        @spacing = 1
+
+        # default to 70 per RFC1436 3.9
+        # "the user display string should be kept under 70 characters in length"
+        @width = 70
+      end
+
+      #
+      # add a line to the output
+      # @param [String] string text to add to the output
+      #
+      def <<(string)
+        @result << string.to_s
+      end
+
+      #
+      # Adds +text+ to the result
+      # @param[String] text text to add to the result. Adds the line,
+      #   then adds any required spacing
+      #
+      def text(text)
+        self << text
+        add_spacing
+      end
+
+      #
+      # specify the desired width of text output -- defaults to 70 chars
+      # @param [Integer] n desired width for text output
+      #
+      def width(n)
+        @width = n.to_i
+      end
+
+      #
+      # specify spacing between lines.
+      #
+      # @param [Integer] n desired line spacing
+      #
+      # @example to make something double-spaced, you could call:
+      #   spacing(2)
+      #
+      def spacing(n)
+        @spacing = n.to_i
+      end
+
+      #
+      # Add some empty lines to the output
+      # @param [Integer] n how many lines to add
+      #
+      def br(n=1)
+        self << (LINE_ENDING * n)
+      end
+
+      #
+      # wrap +text+ into lines no wider than +width+. Hacked from ActionView
+      # @see https://github.com/rails/rails/blob/196407c54f0736c275d2ad4e6f8b0ac55360ad95/actionpack/lib/action_view/helpers/text_helper.rb#L217
+      #
+      # @param [String] text the text you want to wrap
+      # @param [Integer] width the desired width of the block -- defaults to the
+      #   current output width
+      #
+      def block(text, width=@width)
+
+        # this is a hack - recombine lines, then re-split on newlines
+        # doing this because word_wrap is returning an array of lines, but
+        # those lines have newlines in them where we should wrap
+        lines = word_wrap(text, width).join("\n").split("\n")
+
+        lines.each do |line|
+          text line.lstrip.rstrip
+        end
+
+        self.to_s
+      end
+
+      #
+      # output a centered string with a nice underline below it,
+      # centered on the current output width
+      #
+      # @param [String] str - the string to output
+      # @param [String] under - the desired underline character
+      # @param [Boolean] edge - should we output an edge? if so, there will be a
+      #  character to the left/right edges of the string, so you can
+      #  draw a box around the text
+      #
+      def header(str, under = '=', edge = false)
+        w = @width
+        if edge
+          w -= 2
+        end
+
+        tmp = str.center(w)
+        if edge
+          tmp = "#{under}#{tmp}#{under}"
+        end
+
+        text(tmp)
+        underline(@width, under)
+      end
+
+      #
+      # output a centered string in a box
+      # @param [String] str the string to output
+      # @param [Strnig] under the character to use to make the box
+      #
+      def big_header(str, under = '=')
+        br
+        underline(@width, under)
+        header(str, under, true)
+
+        # enforcing some extra space around headers for now
+        br
+      end
+
+      #
+      # output an underline
+      #
+      # @param [Integer] length the length of the underline -- defaults to current
+      #   output width.
+      # @param [String] char the character to output
+      #
+      def underline(length=@width, char='=')
+        text(char * length)
+      end
+
+
+      #
+      # return the output as a string
+      # @return rendered output
+      #
+      def to_s
+        @result
+      end
+
+      protected
+      #
+      # borrowed and modified from ActionView -- wrap text at specified width
+      # returning an array of lines for now in case we want to do nifty processing with them
+      #
+      # File actionpack/lib/action_view/helpers/text_helper.rb, line 217
+      def word_wrap(text, width=70*args)
+        text.split("\n").collect do |line|
+          line.length > width ? line.gsub(/(.{1,#{width}})(\s+|$)/, "\\1\n").strip : line
+        end
+      end
+
+      private
+      def add_spacing
+        br(@spacing)
+      end
+    end
+  end
+end

data/lib/gopher2000/rendering/menu.rb

@@ -0,0 +1,129 @@
+module Gopher
+  module Rendering
+    #
+    # The MenuContext is for rendering gopher menus in the "pseudo
+    # file-system hierarchy" defined by RFC1436
+    #
+    # @see http://www.ietf.org/rfc/rfc1436.txt
+    #
+    class Menu < Base
+
+      # default host value when rendering a line with no selector
+      NO_HOST = '(FALSE)'
+
+      # default port value when rendering a line with no selector
+      NO_PORT = 0
+
+      # Sanitizes text for use in gopher menus
+      # @param [String] text text to cleanup
+      # @return string that can be used in a gopher menu
+      def sanitize_text(raw)
+        raw.
+          rstrip. # Remove excess whitespace
+          gsub(/\t/, ' ' * 8). # Tabs to spaces
+          gsub(/\n/, '') # Get rid of newlines (\r as well?)
+      end
+
+      #
+      # output a gopher menu line
+      #
+      # @param [String] type what sort of entry is this? @see http://www.ietf.org/rfc/rfc1436.txt for a list
+      # @param [String] text the text of the line
+      # @param [String] selector if this is a link, the path of the route we are linking to
+      # @param [String] host for link, defaults to current host
+      # @param [String] port for link, defaults to current port
+      def line(type, text, selector, host=nil, port=nil)
+        text = sanitize_text(text)
+
+        host = application.host if host.nil?
+        port = application.port if port.nil?
+
+        self << ["#{type}#{text}", selector, host, port].join("\t") + LINE_ENDING
+      end
+
+      #
+      # output a line of text, with no selector
+      # @param [String] text the text of the line
+      # @param [String] type what sort of entry is this? @see http://www.ietf.org/rfc/rfc1436.txt for a list
+      #
+      def text(text, type = 'i')
+        line type, text, 'null', NO_HOST, NO_PORT
+      end
+
+      #
+      # add some empty lines to the menu
+      # @param [integer] n how many breaks to add
+      #
+      def br(n=1)
+        1.upto(n) do
+          text 'i', ""
+        end
+        self.to_s
+      end
+
+      #
+      # output an error message
+      # @param [String] msg text of the message
+      #
+      def error(msg)
+        text(msg, '3')
+      end
+
+      #
+      # output a link to a sub-menu/directory
+      # @param [String] name of the menu/directory
+      # @param [String] selector we are linking to
+      # @param [String] host for link, defaults to current host
+      # @param [String] port for link, defaults to current port
+      #
+      def directory(name, selector, host=nil, port=nil)
+        line '1', name, selector, host, port
+      end
+      alias menu directory
+
+
+      #
+      # output a menu link
+      #
+      # @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
+      def link(text, selector, host=nil, port=nil)
+        type = determine_type(selector)
+        line type, text, selector, host, port
+      end
+
+      #
+      # output a search entry
+      # @param [String] text the text of the link
+      # @param [String] selector the path of the selector
+      def search(text, selector, *args)
+        line '7', text, selector, *args
+      end
+      alias input search
+
+
+      #
+      # 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
+      # @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'
+        end
+      end
+    end
+  end
+end

data/lib/gopher2000/rendering/text.rb

@@ -0,0 +1,10 @@
+module Gopher
+  module Rendering
+
+    #
+    # class for text output
+    #
+    class Text < Base
+    end
+  end
+end

data/lib/gopher2000/request.rb

@@ -0,0 +1,21 @@
+module Gopher
+
+  #
+  # basic class for an incoming request
+  #
+  class Request
+    attr_accessor :selector, :input, :ip_address
+
+    def initialize(raw, ip_addr=nil)
+      @selector, @input = raw.chomp.split("\t")
+      @ip_address = ip_addr
+    end
+
+    # confirm that this is actually a valid gopher request
+    # @return [Boolean] true if the request is valid, false otherwise
+    def valid?
+      # The Selector string should be no longer than 255 characters. (RFC 1436)
+      @selector.length <= 255
+    end
+  end
+end

data/lib/gopher2000/response.rb

@@ -0,0 +1,25 @@
+module Gopher
+
+  #
+  # basic class for server response to a request. contains the
+  # rendered results, a code that indicates success/failure, and can
+  # report the size of the response
+  #
+  class Response
+    attr_accessor :body
+    attr_accessor :code
+
+    #
+    # get the size, in bytes, of the response. used for logging
+    # @return [Integer] size
+    #
+    def size
+      case self.body
+      when String then self.body.length
+      when StringIO then self.body.length
+      when File then self.body.size
+      else 0
+      end
+    end
+  end
+end