gopher 0.5.1

data/bin/gopher

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+$:.unshift File.join(File.dirname(__FILE__), '..', 'lib')
+
+require 'gopher'
+
+Gopher.application do
+  host '0.0.0.0'
+  port 70
+
+  mount '/', '.'
+end
+
+Gopher.run

data/lib/ext/module.rb

@@ -0,0 +1,14 @@
+class Module
+  def dsl_accessor(*accessors)
+    accessors.each do |accessor|
+      class_eval %{
+        attr_writer :#{accessor}
+
+        def #{accessor}(value=nil)
+          send "#{accessor}=", value if value
+          @#{accessor}
+        end
+      }
+    end
+  end
+end

data/lib/ext/object.rb

@@ -0,0 +1,17 @@
+# instance_exec for 1.8
+# Grabbed from Mauricio Fernandez (thanks!)
+# For more information, see http://eigenclass.org/hiki.rb?instance_exec
+class Object
+  module InstanceExecHelper; end
+  include InstanceExecHelper
+  def instance_exec(*args, &block) # !> method redefined; discarding old instance_exec
+    mname = "__instance_exec_#{Thread.current.object_id.abs}_#{object_id.abs}"
+    InstanceExecHelper.module_eval{ define_method(mname, &block) }
+    begin
+      ret = send(mname, *args)
+    ensure
+      InstanceExecHelper.module_eval{ undef_method(mname) } rescue nil
+    end
+    ret
+  end
+end

data/lib/gopher.rb

@@ -0,0 +1,298 @@
+$:.unshift File.dirname(__FILE__)
+
+require 'ext/object'
+require 'ext/module'
+
+require 'textwrap'
+require 'yaml'
+require 'eventmachine'
+
+module Gopher
+  VERSION = '0.5.1'
+
+  class Application
+    dsl_accessor :host, :port
+    attr_accessor :selectors, :root
+
+    def initialize(&block)
+      reset!
+      self.instance_eval(&block)
+    end
+
+    def reload(*f); Gopher.reload(*f) end
+
+    def use(mod)
+      extend(mod)
+    end
+
+    def mount(selector, path)
+      add_handler "#{selector}/?(.*)", DirectoryHandler.new(path, selector).with(self)
+    end
+
+    def map(selector, &block)
+      add_handler selector.gsub(/:(.+)/, '(.+)'), MapHandler.new(&block).with(self)
+    end
+
+    def text(selector, &block)
+      add_handler selector.gsub(/:(.+)/, '(.+)'), TextHandler.new(&block).with(self)
+    end
+
+    def helpers(&block)
+      MapContext.class_eval(&block)
+      TextContext.class_eval(&block)
+    end
+
+    def application(selector, handler)
+      add_handler selector, handler
+    end
+
+    def request(selector)
+      handler, *args = lookup(selector)
+      handler.call(*args)
+    end
+
+    def lookup(selector)
+      selectors.find do |k, v|
+        return v, *$~[1..-1] if k =~ Gopher.sanitize_selector(selector)
+      end
+      raise NotFound
+    end
+
+    def add_handler(selector, handler)
+      selector = Gopher.sanitize_selector(selector)
+      selector.sub!(/^\/*/, '')
+      selectors[/^\/?#{selector}$/] = handler
+    end
+
+    private
+    def reset!
+      @selectors = {}
+    end
+  end
+
+  class Handler
+    attr_accessor :application
+
+    def with(application)
+      @application = application
+      self
+    end
+
+    def host; application.respond_to?(:host) ? application.host : '0.0.0.0' end
+    def port; application.respond_to?(:port) ? application.port : 70 end
+
+    def call(*args); end
+  end
+
+  class MapHandler < Handler
+    attr_accessor :block, :result
+
+    def initialize(&block)
+      @block = block
+    end
+
+    def call(*args)
+      context = MapContext.new(host, port)
+      context.instance_exec(*args, &block)
+      context.result
+    end
+  end
+
+  class TextHandler < Handler
+    attr_accessor :block, :result
+
+    def initialize(&block)
+      @block = block
+    end
+
+    def call(*args)
+      context = TextContext.new
+      context.instance_exec(*args, &block)
+      context.result
+    end
+  end
+
+  class DirectoryHandler < Handler
+    attr_accessor :base, :selector, :index
+
+    def initialize(path, selector = '')
+      raise DirectoryNotFound unless File.directory? path
+      @selector = selector
+      @base = File.expand_path(path)
+      @index = YAML.load_file(index_file) if File.exist?(index_file)
+    end
+
+    def call(*args)
+      path = File.join(base, *args)
+      if File.directory? path
+        return DirectoryHandler.new(path, File.join(selector, args)).with(application).to_map
+      elsif File.file? path
+        return File.open(path)
+      else
+        raise NotFound
+      end
+    end
+
+    def to_map
+      MapContext.with_block(host, port, self) do |handler|
+        if handler.index
+          paragraph handler.index['description']
+          handler.index['entries'].each do |txt, path|
+            link txt, File.join(handler.selector, path)
+          end
+        else
+          Dir["#{handler.base}/*"].each do |path|
+            basename = File.basename(path)
+            if File.directory? path
+              map basename, File.join(handler.selector, basename)
+            else
+              link basename, File.join(handler.selector, basename)
+            end
+          end
+        end
+        text Time.now
+      end
+    end
+
+    private
+    def index_file
+      File.join(base, '.gopher')
+    end
+  end
+
+  class TextContext
+    attr_accessor :result
+
+    def line(text)
+      result << text
+      result << "\r\n"
+    end
+
+    def text(text)
+      line text
+    end
+
+    def paragraph(txt, width=70)
+      txt.each_line do |line|
+        Textwrap.wrap(line, width).each { |chunk| text chunk }
+      end
+    end
+
+    def initialize
+      @result = ""
+    end
+  end
+
+  class MapContext
+    attr_accessor :host, :port, :result
+
+    def initialize(host, port)
+      @host, @port = host, port
+      @result = ""
+    end
+
+    def self.with_block(host, port, *args, &block)
+      new(host, port).instance_exec(*args, &block)
+    end
+
+    def line(type, txt, selector, host = host, port = port)
+      result << ["#{type}#{txt}", selector, host, port].join("\t")
+      result << "\r\n"
+    end
+
+    def link(text, selector, *args)
+      type = Gopher.determine_type(selector)
+      line type, text, scrub(selector), *args
+    end
+
+    def map(text, selector, *args)
+      line '1', text, scrub(selector), *args
+    end
+    
+    def text(text)
+      line 'i', text, 'false', '(NULL)', 0
+    end
+
+    def paragraph(txt, width=70)
+      txt.each_line do |line|
+        Textwrap.wrap(line, width).each { |chunk| text chunk }
+      end
+    end
+
+    private
+    def scrub(s)
+      "/#{s.sub(/^\/+/,'')}"
+    end
+  end
+
+  class GopherError < StandardError; end
+  class DirectoryNotFound < GopherError; end
+  class NotFound < GopherError; end
+  class InvalidRequest < GopherError; end
+
+  def self.sanitize_selector(selector)
+    selector = selector.dup
+    selector.strip!
+    selector.gsub!(/\.+/, '.')
+    selector
+  end
+  def self.determine_type(selector)
+    case File.extname(selector).downcase
+    when '.jpg', '.png' then 'I'
+    when '.mp3' then 's'
+    else '0'
+    end
+  end
+
+  class Connection < EM::Connection
+    attr_accessor :application
+
+    def receive_data(data)
+      begin
+        raise InvalidRequest if data.length > 255
+        response = application.request(data)        
+        case response
+        when String then send_data(response)
+        when StringIO then send_data(response.read)
+        when File
+          while chunk = response.read(8192) do
+            send_data(chunk)
+          end
+        end
+        close_connection_after_writing
+      rescue Gopher::NotFound
+        send_data "not found"
+        close_connection_after_writing
+      rescue => e
+        close_connection
+        raise e
+      end
+    end
+  end
+
+  def self.application(&block)
+    @application = Application.new(&block)
+  end
+
+  def self.reload(*files)
+    @last_reload = Time.now
+    @reloadables = files
+  end
+
+  def self.reloadables
+    @reloadables ||= []
+  end
+
+  def self.run
+    return if EM.reactor_running?
+    EM.run do
+      EM.start_server(@application.host, @application.port, Gopher::Connection) do |c|
+        c.application = @application
+        reloadables.each do |f|
+          load f if File.mtime(f) > @last_reload
+        end
+        @last_reload = Time.now
+      end        
+    end
+  end
+end

data/lib/gopher/redirect.erb

@@ -0,0 +1,4 @@
+<!DOCTYPE html>
+<title>gopher.rb redirect</title>
+<meta http-equiv="refresh" content="2;URL=<%= url %>">
+<p>Redirecting to external url <%= url %></p>

data/lib/gopher/redirect.rb

@@ -0,0 +1,25 @@
+require 'erubis'
+
+module Gopher
+  module Redirect
+    def self.extended(application)
+      application.add_handler "URL:(.+)", RedirectHandler.new.with(application)
+      application.class.dsl_accessor :redirect_template
+      application.redirect_template File.join(File.dirname(__FILE__), 'redirect.erb')
+
+      application.helpers do
+        def url(text, url, *args)
+          line 'h', text, "/URL:#{url}", *args
+        end
+      end
+    end
+
+    class RedirectHandler < Handler
+      def call(*url)
+        input = File.read(application.redirect_template)
+        eruby = Erubis::Eruby.new(input)
+        return eruby.result(binding())
+      end
+    end
+  end
+end

data/spec/application_spec.rb

@@ -0,0 +1,42 @@
+require File.join(File.dirname(__FILE__), '/spec_helper')
+
+describe Gopher::Application do
+  before(:all) do
+    @app = Gopher::Application.new do
+      host 'pha.hk'
+      port 7000
+
+      helpers do
+        def ruler
+          text ("=-" * 40)
+        end
+      end
+
+      mount 'documents', File.dirname(__FILE__)
+    end
+  end
+
+  it 'should set the host' do
+    @app.host.should == 'pha.hk'
+  end
+
+  it 'should set the port' do
+    @app.port.should == 7000
+  end
+
+  it 'should mount directories' do
+    @app.lookup('/documents').should be_instance_of(Array)
+  end
+
+  it 'should route properly to directories and their children' do
+    @app.lookup('/documents/tasty').should include("tasty")
+  end
+
+  it 'should sanitize lookups' do
+    @app.lookup('/documents/.././tasty...html').should include("././tasty.html")
+  end
+
+  it 'should add helpers' do
+    Gopher::MapContext.public_instance_methods.should include('ruler')
+  end
+end

data/spec/ext_spec.rb

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

data/spec/gopher_spec.rb

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

data/spec/handler_spec.rb

@@ -0,0 +1,45 @@
+require File.join(File.dirname(__FILE__), '/spec_helper')
+
+describe Gopher::DirectoryHandler do
+  before(:all) do
+    path = File.join(File.dirname(__FILE__), 'sandbox')
+    @handler = Gopher::DirectoryHandler.new(path)
+  end
+
+  it 'should barf on non-existent directories' do
+    proc { Gopher::DirectoryHandler.new(__FILE__) }.should raise_error(Gopher::DirectoryNotFound)
+  end
+
+  it 'should serve files under the directory' do
+    @handler.call('recipe.txt').should be_instance_of(File)
+  end
+
+  it 'should raise a NotFound when files do not exist' do
+    proc { @handler.call('recipe.tx') }.should raise_error(Gopher::NotFound)
+  end
+
+  it 'should serve generated directory maps' do
+    @handler.call('indexed').should include("An indexed directory")
+  end
+
+  it 'should serve directory indexes when applicable' do
+    @handler.call.should include("0recipe.txt\t/recipe.txt\t0.0.0.0\t70\r\n")
+  end
+end
+
+describe Gopher::MapHandler do
+  before(:all) do
+    @handler = Gopher::MapHandler.new do
+      text 'Cake recipes'
+      link 'Image', 'cake.jpg'
+    end
+  end
+
+  it 'should add text' do
+    @handler.call.should include "iCake recipes\tfalse\t(NULL)\t0\r\n"
+  end
+
+  it 'should add links and figure out the types' do
+    @handler.call.should include "IImage\t/cake.jpg\t0.0.0.0\t70\r\n"
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,2 @@
+require File.join(File.dirname(__FILE__), '/../lib/gopher')
+require 'spec'

metadata

@@ -0,0 +1,69 @@
+--- !ruby/object:Gem::Specification 
+name: gopher
+version: !ruby/object:Gem::Version 
+  version: 0.5.1
+platform: ruby
+authors: 
+- raspberry lemon
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-05-22 00:00:00 +02:00
+default_executable: 
+dependencies: []
+
+description: 
+email: lemon@raspberry-style.net
+executables: 
+- gopher
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- bin/gopher
+- lib/ext
+- lib/ext/module.rb
+- lib/ext/object.rb
+- lib/gopher
+- lib/gopher/redirect.erb
+- lib/gopher/redirect.rb
+- lib/gopher.rb
+- spec/application_spec.rb
+- spec/ext_spec.rb
+- spec/gopher_spec.rb
+- spec/handler_spec.rb
+- spec/sandbox
+- spec/sandbox/indexed
+- spec/sandbox/indexed/cake.txt
+- spec/sandbox/recipe.txt
+- spec/spec_helper.rb
+has_rdoc: false
+homepage: http://raspberry-style.net/
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.1.1
+signing_key: 
+specification_version: 2
+summary: gopher server and dsl
+test_files: []
+