gopher2000 0.1.0

data/lib/gopher2000/server.rb

@@ -0,0 +1,85 @@
+module Gopher
+
+  #
+  # main class which will listen on a specified port, and pass requests to an Application class
+  #
+  class Server
+    attr_accessor :app
+
+    #
+    # constructor
+    # @param [Application] instance of Gopher::Application we want to run
+    #
+    def initialize(a)
+      @app = a
+    end
+
+    #
+    # @return [String] name of the host specified in our config
+    #
+    def host
+      @app.config[:host] ||= '0.0.0.0'
+    end
+
+    #
+    # @return [Integer] port specified in our config
+    #
+    def port
+      @app.config[:port] ||= 70
+    end
+
+    #
+    # main app loop. called via at_exit block defined in DSL
+    #
+    def run!
+      EventMachine::run do
+        Signal.trap("INT") {
+          puts "It's a trap!"
+          EventMachine.stop
+        }
+        Signal.trap("TERM") {
+          puts "It's a trap!"
+          EventMachine.stop
+        }
+
+        EventMachine.kqueue = true if EventMachine.kqueue?
+        EventMachine.epoll = true if EventMachine.epoll?
+
+
+        STDERR.puts "start server at #{host} #{port}"
+        if @app.non_blocking?
+          STDERR.puts "Not blocking on requests"
+        end
+
+
+        EventMachine::start_server(host, port, Gopher::Dispatcher) do |conn|
+          #
+          # check if we should reload any scripts before moving along
+          #
+          @app.reload_stale
+
+          #
+          # roughly matching sinatra's style of duping the app to respond
+          # to requests, @see http://www.sinatrarb.com/intro#Request/Instance%20Scope
+          #
+          # this essentially means we have 'one instance per request'
+          #
+          conn.app = @app.dup
+        end
+      end
+    end
+
+
+    #
+    # don't try and parse arguments if someone already has done that
+    #
+    if ARGV.any? && ! defined?(OptionParser)
+      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 }
+      }.parse!(ARGV.dup)
+    end
+  end
+end

data/lib/gopher2000/version.rb

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

data/lib/gopher2000.rb

@@ -0,0 +1,33 @@
+require 'logging'
+require 'eventmachine'
+require 'stringio'
+
+
+#
+# Define everything needed to run a gopher server
+#
+module Gopher
+  require "gopher2000/version"
+  require "gopher2000/errors"
+
+  require 'gopher2000/rendering/abstract_renderer'
+  require 'gopher2000/rendering/base'
+  require 'gopher2000/rendering/text'
+  require 'gopher2000/rendering/menu'
+
+  require 'gopher2000/request'
+  require 'gopher2000/response'
+
+  require 'gopher2000/handlers/base_handler'
+  require 'gopher2000/handlers/directory_handler'
+  require 'gopher2000/base'
+  require 'gopher2000/server'
+
+  require 'gopher2000/dispatcher'
+end
+
+#
+# include Gopher DSL in the main object space
+#
+require 'gopher2000/dsl'
+include Gopher::DSL

data/scripts/god.rb

@@ -0,0 +1,8 @@
+God.watch do |w|
+  w.name = "gopher"
+  w.dir = "/home/colin/Projects/gopher2000"
+  w.start = "bundle exec /home/colin/Projects/gopher2000/examples/simple.rb"
+  w.keepalive
+  w.log = '/tmp/gopher.log'
+
+end

data/spec/application_spec.rb

@@ -0,0 +1,54 @@
+require File.join(File.dirname(__FILE__), '/spec_helper')
+require 'tempfile'
+
+describe Gopher::Application do
+  before(:each) do
+    @app = Gopher::Application.new
+    @app.reset!
+    @app.scripts = []
+  end
+
+  it 'should have default host/port' do
+    @app.host.should == "0.0.0.0"
+    @app.port.should == 70
+  end
+
+  describe "should_reload?" do
+    it "is false if no scripts" do
+      @app.should_reload?.should == false
+    end
+
+    it "shouldn't do anything if last_reload not set" do
+      @app.last_reload.should be_nil
+      @app.scripts << "foo.rb"
+      @app.should_reload?.should == false
+    end
+
+    it "should check script date" do
+      now = Time.now
+      Time.stub!(:now).and_return(now)
+
+      @app.last_reload = Time.now - 1000
+      @app.scripts << "foo.rb"
+      File.should_receive(:mtime).with("foo.rb").and_return(now)
+
+      @app.should_reload?.should == 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)
+
+      @app.should_receive(:should_reload?).and_return(true)
+
+      @app.last_reload = Time.now - 1000
+      @app.scripts << "foo.rb"
+      @app.should_receive(:load).with("foo.rb")
+      @app.reload_stale
+
+      @app.last_reload.should == now
+    end
+  end
+end

data/spec/dispatching_spec.rb

@@ -0,0 +1,144 @@
+require File.join(File.dirname(__FILE__), '/spec_helper')
+
+class MockApplication < Gopher::Application
+  attr_accessor :menus, :routes, :config, :scripts, :last_reload
+
+  def initialize
+    @routes = []
+    @menus = {}
+    @scripts ||= []
+    @config = {}
+
+    register_defaults
+  end
+end
+
+describe Gopher::Application do
+  before(:each) do
+    @server = MockApplication.new
+  end
+
+  describe "lookup" do
+    it "should work with simple route" do
+      @server.route '/about' do; end
+      @request = Gopher::Request.new("/about")
+
+      keys, block = @server.lookup(@request.selector)
+      keys.should == {}
+    end
+
+    it "should translate path" do
+      @server.route '/about/:foo/:bar' do;  end
+      @request = Gopher::Request.new("/about/x/y")
+
+      keys, block = @server.lookup(@request.selector)
+      keys.should == {:foo => 'x', :bar => 'y'}
+    end
+
+    it "should return default route if no other route found, and default is defined" do
+      @server.default_route do
+        "DEFAULT ROUTE"
+      end
+      @request = Gopher::Request.new("/about/x/y")
+      @response = @server.dispatch(@request)
+      @response.body.should == "DEFAULT ROUTE"
+      @response.code.should == :success
+    end
+
+    it "should respond with error if no route found" do
+      @server.route '/about/:foo/:bar' do;  end
+      @request = Gopher::Request.new("/junk/x/y")
+
+      @response = @server.dispatch(@request)
+      @response.code.should == :missing
+    end
+
+    it "should respond with error if invalid request" do
+      @server.route '/about/:foo/:bar' do;  end
+      @request = Gopher::Request.new("x" * 256)
+
+      @response = @server.dispatch(@request)
+      @response.code.should == :error
+    end
+
+    it "should respond with error if there's an exception" do
+      @server.route '/x' do; raise Exception; end
+      @request = Gopher::Request.new("/x")
+
+      @response = @server.dispatch(@request)
+      @response.code.should == :error
+    end
+  end
+
+  describe "dispatch" do
+    before(:each) do
+      #@server.should_receive(:lookup).and_return({})
+      @server.route '/about' do
+        'GOPHERTRON'
+      end
+
+      @request = Gopher::Request.new("/about")
+    end
+
+    it "should run the block" do
+      @response = @server.dispatch(@request)
+      @response.body.should == "GOPHERTRON"
+    end
+  end
+
+  describe "dispatch, with params" do
+    before(:each) do
+      @server.route '/about/:x/:y' do
+        params.to_a.join("/")
+      end
+
+      @request = Gopher::Request.new("/about/a/b")
+    end
+
+    it "should use incoming params" do
+      @response = @server.dispatch(@request)
+      @response.body.should == "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)
+
+      @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)
+
+      @response = @server.dispatch(@request)
+      @response.code.should == :success
+    end
+
+    it "should work for subdir" do
+      @request = Gopher::Request.new("/foo/bar")
+      @h.should_receive(:call).with({:splat => "bar"}, @request)
+
+      @response = @server.dispatch(@request)
+      @response.code.should == :success
+    end
+  end
+
+
+  describe "globs" do
+    before(:each) do
+      @server.route '/about/*' do
+        params[:splat]
+      end
+    end
+
+    it "should put wildcard into param[:splat]" do
+      @request = Gopher::Request.new("/about/a/b")
+      @response = @server.dispatch(@request)
+      @response.body.should == "a/b"
+    end
+  end
+end

data/spec/dsl_spec.rb

@@ -0,0 +1,116 @@
+require File.join(File.dirname(__FILE__), '/spec_helper')
+
+class FakeApp < Gopher::Application
+
+end
+
+class FakeServer < Gopher::Server
+
+end
+
+describe Gopher::DSL do
+  before(:each) do
+    @app = FakeApp.new
+
+    @server = FakeServer.new(@app)
+    @server.send :require, 'gopher2000/dsl'
+    @server.stub!(:application).and_return(@app)
+    @app.reset!
+  end
+
+
+  describe "set" do
+    it "should set a config var" do
+      @server.set :foo, 'bar'
+      @app.config[:foo].should == 'bar'
+    end
+  end
+
+  describe "route" do
+    it "should pass a lookup and block to the app" do
+      @app.should_receive(:route).with('/foo')
+      @server.route '/foo' do
+        "hi"
+      end
+    end
+  end
+
+  describe "default_route" do
+    it "should pass a default block to the app" do
+      @app.should_receive(:default_route)
+      @server.default_route do
+        "hi"
+      end
+    end
+  end
+
+  describe "mount" do
+    it "should pass a route, path, and some opts to the app" do
+      @app.should_receive(:mount).with('/foo', {:path => "/bar"})
+      @server.mount "/foo" => "/bar"
+    end
+
+    it "should pass a route, path, filter, and some opts to the app" do
+      @app.should_receive(:mount).with('/foo', {:path => "/bar", :filter => "*.jpg"})
+      @server.mount "/foo" => "/bar", :filter => "*.jpg"
+    end
+  end
+
+  describe "menu" do
+    it "should pass a menu key and block to the app" do
+      @app.should_receive(:menu).with('/foo')
+      @server.menu '/foo' do
+        "hi"
+      end
+    end
+  end
+
+  describe "text" do
+    it "should pass a text_template key and block to the app" do
+      @app.should_receive(:text).with('/foo')
+      @server.text '/foo' do
+        "hi"
+      end
+    end
+  end
+
+  describe "helpers" do
+    it "should pass a block to the app" do
+      @app.should_receive(:helpers)
+      @server.helpers do
+        "hi"
+      end
+    end
+  end
+
+  describe "watch" do
+    it "should pass a script app for watching" do
+      @app.scripts.should_receive(:<<).with("foo")
+      @server.watch("foo")
+    end
+  end
+
+  describe "run" do
+    it "should set any incoming opts" do
+      @server.should_receive(:set).with(:x, 1)
+      @server.should_receive(:set).with(:y, 2)
+      @server.stub!(:load)
+
+      @server.run("foo", {:x => 1, :y => 2})
+    end
+
+    it "should turn on script watching if in debug mode" do
+      @app.config[:debug] = true
+      @server.should_receive(:watch).with("foo.rb")
+      @server.should_receive(:load).with("foo.rb")
+
+      @server.run("foo.rb")
+    end
+
+    it "should load the script" do
+      @server.should_receive(:load).with("foo.rb")
+      @server.run("foo.rb")
+    end
+  end
+
+end

data/spec/gopher_spec.rb

@@ -0,0 +1 @@
+require File.join(File.dirname(__FILE__), '/spec_helper')

data/spec/handlers/directory_handler_spec.rb

@@ -0,0 +1,116 @@
+require File.join(File.dirname(__FILE__), '..', '/spec_helper')
+
+describe Gopher::Handlers::DirectoryHandler do
+  before(:each) do
+    app = mock(Gopher::Application,
+      :host => "host",
+      :port => 1234,
+      :config => {})
+
+    @h = Gopher::Handlers::DirectoryHandler.new(:path => "/tmp", :mount_point => "/xyz/123")
+    @h.application = app
+  end
+
+  describe "filtering" do
+    before(:each) do
+      File.should_receive(:directory?).with("/tmp/bar/baz").and_return(true)
+      File.should_receive(:directory?).with("/tmp/bar/baz/a.txt").and_return(false)
+      File.should_receive(:directory?).with("/tmp/bar/baz/b.exe").and_return(false)
+      File.should_receive(:directory?).with("/tmp/bar/baz/dir2").and_return(true)
+
+      File.should_receive(:file?).with("/tmp/bar/baz/a.txt").and_return(true)
+      File.should_receive(:file?).with("/tmp/bar/baz/b.exe").and_return(true)
+
+      File.should_receive(:fnmatch).with("*.txt", "/tmp/bar/baz/a.txt").and_return(true)
+      File.should_receive(:fnmatch).with("*.txt", "/tmp/bar/baz/b.exe").and_return(false)
+
+      Dir.should_receive(:glob).with("/tmp/bar/baz/*.*").and_return([
+          "/tmp/bar/baz/a.txt",
+          "/tmp/bar/baz/b.exe",
+          "/tmp/bar/baz/dir2"])
+
+      @h.filter = "*.txt"
+    end
+
+    it "should use right filter" do
+      @h.call(:splat => "bar/baz")
+    end
+  end
+
+  describe "request_path" do
+    it "should join existing path with incoming path" do
+      @h.request_path(:splat => "bar/baz").should == "/tmp/bar/baz"
+    end
+  end
+
+  describe "to_selector" do
+    it "should work" do
+      @h.to_selector("/tmp/foo/bar.html").should == "/xyz/123/foo/bar.html"
+      @h.to_selector("/tmp/foo/baz").should == "/xyz/123/foo/baz"
+      @h.to_selector("/tmp").should == "/xyz/123"
+    end
+  end
+
+  describe "contained?" do
+    it "should be false if not under base path" do
+      @h.contained?("/home/gopher").should == false
+    end
+    it "should be true if under base path" do
+      @h.contained?("/tmp/gopher").should == true
+    end
+  end
+
+  describe "safety checks" do
+    it "should raise exception for invalid directory" do
+      lambda {
+        @h.call(:splat => "../../../home/foo/bar/baz").to_s.should == "0a\t/tmp/bar/baz/a\thost\t1234"
+     }.should raise_error(Gopher::InvalidRequest)
+    end
+  end
+
+  describe "directories" do
+    before(:each) do
+      File.should_receive(:directory?).with("/tmp/bar/baz").and_return(true)
+      File.should_receive(:directory?).with("/tmp/bar/baz/a").and_return(false)
+      File.should_receive(:directory?).with("/tmp/bar/baz/dir2").and_return(true)
+
+      File.should_receive(:file?).with("/tmp/bar/baz/a").and_return(true)
+      File.should_receive(:fnmatch).with("*.*", "/tmp/bar/baz/a").and_return(true)
+
+      Dir.should_receive(:glob).with("/tmp/bar/baz/*.*").and_return([
+          "/tmp/bar/baz/a",
+          "/tmp/bar/baz/dir2"])
+    end
+
+    it "should work" do
+      @h.call(:splat => "bar/baz").to_s.should == "iBrowsing: /tmp/bar/baz\tnull\t(FALSE)\t0\r\n0a\t/xyz/123/bar/baz/a\thost\t1234\r\n1dir2\t/xyz/123/bar/baz/dir2\thost\t1234\r\n"
+    end
+  end
+
+  describe "files" do
+    before(:each) do
+      @file = mock(File)
+      File.should_receive(:directory?).with("/tmp/baz.txt").and_return(false)
+
+      File.should_receive(:file?).with("/tmp/baz.txt").and_return(true)
+      File.should_receive(:new).with("/tmp/baz.txt").and_return(@file)
+    end
+
+    it "should work" do
+      @h.call(:splat => "baz.txt").should == @file
+    end
+  end
+
+  describe "missing stuff" do
+    before(:each) do
+      File.should_receive(:directory?).with("/tmp/baz.txt").and_return(false)
+      File.should_receive(:file?).with("/tmp/baz.txt").and_return(false)
+    end
+
+    it "should return not found" do
+      lambda {
+        @h.call(:splat => "baz.txt")
+      }.should raise_error(Gopher::NotFoundError)
+    end
+  end
+end

data/spec/helpers_spec.rb

@@ -0,0 +1,16 @@
+require File.join(File.dirname(__FILE__), '/spec_helper')
+
+describe Gopher::Application do
+  before(:each) do
+    @obj = Gopher::Application.new
+#    @obj.extend(Gopher::Helpers)
+  end
+
+  it 'should add code to target class' do
+    @obj.helpers do
+      def foo; "FOO"; end
+    end
+
+    @obj.foo.should == "FOO"
+  end
+end

data/spec/rendering/base_spec.rb

@@ -0,0 +1,59 @@
+require File.join(File.dirname(__FILE__), '/../spec_helper')
+
+describe Gopher::Rendering::Base do
+  before(:each) do
+    @ctx = Gopher::Rendering::Base.new
+  end
+
+  it 'should add text' do
+    @ctx.text("line 1")
+    @ctx.text("line 2")
+    @ctx.result.should == "line 1\r\nline 2\r\n"
+  end
+
+  it "should add breaks correctly" do
+    @ctx.spacing 2
+    @ctx.text("line 1")
+    @ctx.text("line 2")
+    @ctx.result.should == "line 1\r\n\r\nline 2\r\n\r\n"
+  end
+
+  it "br outputs a bunch of newlines" do
+    @ctx.br(2).should == "\r\n\r\n"
+  end
+
+  describe "underline" do
+    it "underline outputs a pretty line" do
+      @ctx.underline(1, 'x').should == "x\r\n"
+    end
+    it "has defaults" do
+      @ctx.underline.should == "=" * 70 + "\r\n"
+    end
+  end
+
+  describe "big_header" do
+    it "outputs a box with text" do
+      @ctx.width(5)
+      @ctx.big_header('pie').should == "\r\n=====\r\n=pie=\r\n=====\r\n\r\n"
+    end
+  end
+
+  describe "header" do
+    it "outputs underlined text" do
+      @ctx.width(5)
+      @ctx.header('pie').should == " pie \r\n=====\r\n"
+    end
+  end
+
+  it "uses to_s to output result" do
+    @ctx.text("line 1")
+    @ctx.to_s.should == @ctx.result
+  end
+
+  describe "block" do
+    it "wraps text" do
+      @ctx.should_receive(:text).twice.with "a"
+      @ctx.block("a a",1)
+    end
+  end
+end