hermeneutics 1.8

data/lib/hermeneutics/boxes.rb

@@ -0,0 +1,321 @@
+#
+#  hermeneutics/boxes.rb  --  Mailboxes
+#
+
+=begin rdoc
+
+:section: Classes definied here
+
+Hermeneutics::Box is a general Mailbox.
+
+Hermeneutics::MBox is the traditional mbox format (text file, separated by a
+blank line).
+
+Hermeneutics::Maildir is the maildir format.
+
+
+=end
+
+
+require "supplement"
+require "supplement/locked"
+require "date"
+
+
+module Hermeneutics
+
+  # Mailboxes
+  class Box
+
+    @boxes = []
+
+    class <<self
+
+      # :call-seq:
+      #   Box.find( path, default = nil)          -> box
+      #
+      # Create a Box object (some subclass of Box), depending on
+      # what type the box is found at <code>path</code>.
+      #
+      def find path, default_format = nil
+        b = @boxes.find { |b| b.check path }
+        b ||= default_format
+        b ||= if File.directory? path then
+          Maildir
+        elsif File.file? path then
+          MBox
+        else
+          # If still nothing was found use Postfix convention:
+          path =~ /\/$/ ? Maildir : MBox
+        end
+        b.new path
+      end
+
+      # :call-seq:
+      #   Box.check( path)     -> nil
+      #
+      # By default, subclass mailboxes do not exist. You should overwrite
+      # this behaviour.
+      #
+      def check path
+      end
+
+      protected
+      attr_reader :boxes
+      def inherited cls
+        Box.boxes.push cls
+      end
+
+    end
+
+    # :call-seq:
+    #   Box.new( path)          -> box
+    #
+    # Instantiate a Box object, just store the <code>path</code>.
+    #
+    def initialize mailbox
+      @mailbox = mailbox
+    end
+
+    def to_s ; path ; end
+
+    def path ; @mailbox ; end
+
+    # :call-seq:
+    #   box.exists?     -> true or false
+    #
+    # Test whether the <code>Box</code> exists.
+    #
+    def exists?
+      self.class.check @mailbox
+    end
+
+  end
+
+  class MBox < Box
+
+    RE_F = /^From\s+/      # :nodoc:
+    RE_N = /^$/            # :nodoc:
+
+    class <<self
+
+      # :call-seq:
+      #   MBox.check( path)     -> true or false
+      #
+      # Check whether path is a <code>MBox</code>.
+      #
+      def check path
+        if File.file? path then
+          File.open path, :encoding => Encoding::ASCII_8BIT do |f|
+            f.size.zero? or f.readline =~ RE_F
+          end
+        end
+      end
+
+    end
+
+    # :stopdoc:
+    class Region
+      class <<self
+        private :new
+        def open file, start, stop
+          t = file.tell
+          begin
+            i = new file, start, stop
+            yield i
+          ensure
+            file.seek t
+          end
+        end
+      end
+      def initialize file, start, stop
+        @file, @start, @stop = file, start, stop
+        rewind
+      end
+      def rewind ; @file.seek @start ; end
+      def read n = nil
+        m = @stop - @file.tell
+        n = m if not n or n > m
+        @file.read n
+      end
+      def to_s
+        rewind
+        read
+      end
+      def each_line
+        @file.each_line { |l|
+          break if @file.tell > @stop
+          yield l
+        }
+      end
+      alias eat_lines each_line
+    end
+    # :startdoc:
+
+    # :call-seq:
+    #   mbox.create     -> self
+    #
+    # Create the <code>MBox</code>.
+    #
+    def create
+      d = File.dirname @mailbox
+      Dir.mkdir! d
+      File.open @mailbox, File::CREAT do |f| end
+      self
+    end
+
+    # :call-seq:
+    #   mbox.deliver( msg)     -> nil
+    #
+    # Store the mail into the local <code>MBox</code>.
+    #
+    def deliver msg
+      pos = nil
+      LockedFile.open @mailbox, "r+", :encoding => Encoding::ASCII_8BIT do |f|
+        f.seek [ f.size - 4, 0].max
+        last = ""
+        f.read.each_line { |l| last = l }
+        f.puts unless last =~ /^$/
+        pos = f.size
+        m = msg.to_s
+        i = 1
+        while (i = m.index RE_F, i rescue nil) do m.insert i, ">" end
+        f.write m
+        f.puts
+      end
+      pos
+    end
+
+    # :call-seq:
+    #   mbox.each { |mail| ... }    -> nil
+    #
+    # Iterate through <code>MBox</code>.
+    #
+    def each &block
+      File.open @mailbox, :encoding => Encoding::ASCII_8BIT do |f|
+        m, e = nil, true
+        s, t = t, f.tell
+        f.each_line { |l|
+          s, t = t, f.tell
+          if is_from_line? l and e then
+            begin
+              m and Region.open f, m, e, &block
+            ensure
+              m, e = s, nil
+            end
+          else
+            m or raise "#@mailbox does not seem to be a mailbox."
+            e = l =~ RE_N && s
+          end
+        }
+        # Treat it gracefully when there is no empty last line.
+        e ||= f.tell
+        m and Region.open f, m, e, &block
+      end
+    end
+    include Enumerable
+
+    private
+
+    def is_from_line? l
+      l =~ RE_F or return
+      addr, time = $'.split nil, 2
+      DateTime.parse time
+      addr =~ /@/
+    rescue ArgumentError, TypeError
+    end
+
+  end
+
+  class Maildir < Box
+
+    DIRS = %w(cur tmp new)
+    CUR, TMP, NEW = *DIRS
+
+    class <<self
+
+      # :call-seq:
+      #   Maildir.check( path)     -> true or false
+      #
+      # Check whether path is a <code>Maildir</code>.
+      #
+      def check mailbox
+        if File.directory? mailbox then
+          DIRS.each do |d|
+            s = File.join mailbox, d
+            File.directory? s or return false
+          end
+          true
+        end
+      end
+
+    end
+
+    # :call-seq:
+    #   maildir.create     -> self
+    #
+    # Create the <code>Maildir</code>.
+    #
+    def create
+      Dir.mkdir! @mailbox
+      DIRS.each do |d|
+        s = File.join @mailbox, d
+        Dir.mkdir s
+      end
+      self
+    end
+
+    # :call-seq:
+    #   maildir.deliver( msg)     -> nil
+    #
+    # Store the mail into the local <code>Maildir</code>.
+    #
+    def deliver msg
+      tmp = mkfilename TMP
+      File.open tmp, "w" do |f|
+        f.write msg
+      end
+      new = mkfilename NEW
+      File.rename tmp, new
+      new
+    end
+
+    # :call-seq:
+    #   mbox.each { |mail| ... }    -> nil
+    #
+    # Iterate through <code>MBox</code>.
+    #
+    def each
+      p = File.join @mailbox, CUR
+      d = Dir.new p
+      d.each { |f|
+        next if f.starts_with? "."
+        File.open f, :encoding => Encoding::ASCII_8BIT do |f|
+          yield f
+        end
+      }
+    end
+    include Enumerable
+
+    private
+
+    autoload :Socket, "socket"
+
+    def mkfilename d
+      dir = File.join @mailbox, d
+      c = 0
+      begin
+        n = "%.4f.%d_%d.%s" % [ Time.now.to_f, $$, c, Socket.gethostname]
+        path = File.join dir, n
+        File.open path, File::CREAT|File::EXCL do |f| end
+        path
+      rescue Errno::EEXIST
+        c += 1
+        retry
+      end
+    end
+
+  end
+
+end
+

data/lib/hermeneutics/cgi.rb

@@ -0,0 +1,253 @@
+#
+#  hermeneutics/cgi.rb  -- CGI responses
+#
+
+require "hermeneutics/escape"
+require "hermeneutics/message"
+require "hermeneutics/html"
+
+
+module Hermeneutics
+
+  class Html
+
+    CONTENT_TYPE = "text/html"
+
+    attr_reader :cgi
+
+    def initialize cgi
+      @cgi = cgi
+    end
+
+    def form! **attrs, &block
+      attrs[ :action] = @cgi.fullpath attrs[ :action]
+      form **attrs, &block
+    end
+
+    def href dest, params = nil, anchor = nil
+      @utx ||= URLText.new
+      dest = @cgi.fullpath dest
+      @utx.mkurl dest, params, anchor
+    end
+
+    def href! params = nil, anchor = nil
+      href nil, params, anchor
+    end
+
+  end
+
+
+  # Example:
+  #
+  # class MyCgi < Cgi
+  #   def run
+  #     p = parameters
+  #     if p.empty? then
+  #       location "/sorry.rb"
+  #     else
+  #       document MyHtml
+  #     end
+  #   rescue
+  #     document MyErrorPage
+  #   end
+  # end
+  # Cgi.execute
+  #
+  class Cgi
+
+    class <<self
+      attr_accessor :main
+      def inherited cls
+        Cgi.main = cls
+      end
+      def execute out = nil
+        (@main||self).new.execute out
+      end
+    end
+
+    # Overwrite this.
+    def run
+      document Html
+    end
+
+    def parameters inp = nil, &block
+      if block_given? then
+        case request_method
+          when "GET", "HEAD" then parse_query query_string, &block
+          when "POST"        then parse_posted inp||$stdin, &block
+          else                    parse_input &block
+        end
+      else
+        p = {}
+        parameters do |k,v|
+          p[ k] = v
+        end
+        p
+      end
+    end
+
+    CGIENV = %w(content document gateway http query
+                          remote request script server unique)
+
+    def method_missing sym, *args
+      if args.empty? and CGIENV.include? sym[ /\A(\w+?)_\w+\z/, 1] then
+        ENV[ sym.to_s.upcase]
+      else
+        super
+      end
+    end
+
+    def https?
+      ENV[ "HTTPS"].notempty?
+    end
+
+    private
+
+    def parse_query data, &block
+      URLText.decode_hash data, &block
+    end
+
+    def parse_posted inp, &block
+      data = inp.read
+      data.bytesize == content_length.to_i or
+        @warn = "Content length #{content_length} is wrong (#{data.bytesize})."
+      ct = ContentType.parse content_type
+      case ct.fulltype
+        when "application/x-www-form-urlencoded" then
+          parse_query data, &block
+        when "multipart/form-data" then
+          mp = Multipart.parse data, ct.hash
+          parse_multipart mp, &block
+        when "text/plain" then
+          # Suppose this is for testing purposes only.
+          mk_params data.lines, &block
+        else
+          parse_query data, &block
+      end
+    end
+
+    def parse_multipart mp
+      mp.each { |part|
+        cd = part.headers.content_disposition
+        if cd.caption == "form-data" then
+          yield cd.name, part.body, **cd.hash
+        end
+      }
+    end
+
+    def mk_params l
+      l.each { |s|
+        k, v = s.split %r/=/
+        v ||= k
+        [k, v].each { |x| x.strip! }
+        yield k, v
+      }
+    end
+
+    def parse_input &block
+      if $*.any? then
+        l = $*
+      else
+        if $stdin.tty? then
+          $stderr.puts <<~EOT
+            Offline mode: Enter name=value pairs on standard input.
+          EOT
+        end
+        l = []
+        while (a = $stdin.gets) and a !~ /^$/ do
+          l.push a
+        end
+      end
+      ENV[ "SCRIPT_NAME"] = $0
+      mk_params l, &block
+    end
+
+
+    class Done < Exception
+      attr_reader :result
+      def initialize result
+        super nil
+        @result = result
+      end
+    end
+
+    def done ct = nil
+      res = Message.create
+      yield res
+      d = Done.new res
+      raise d
+    end
+
+    public
+
+    def execute out = nil
+      @out ||= $stdout
+      begin
+        run
+      rescue
+        done { |res|
+          res.body = "#$! (#{$!.class})#$/"
+          $@.each { |a| res.body << "\t" << a << $/ }
+          res.headers.add :content_type,
+                            "text/plain", charset: res.body.encoding
+        }
+      end
+    rescue Done
+      @out << $!.result.to_s
+    ensure
+      @out = nil
+    end
+
+    def document cls = Html, *args, &block
+      done { |res|
+        doc = cls.new self
+        res.body = ""
+        doc.generate res.body do
+          doc.document *args, &block
+        end
+
+        ct = if doc.respond_to?    :content_type then doc.content_type
+        elsif   cls.const_defined? :CONTENT_TYPE then doc.class::CONTENT_TYPE
+        end
+        ct and res.headers.add :content_type, ct,
+                    charset: res.body.encoding||Encoding.default_external
+        if doc.respond_to? :cookies then
+          doc.cookies do |c|
+            res.headers.add :set_cookie, c
+          end
+        end
+      }
+    end
+
+    def location dest = nil, params = nil, anchor = nil
+      if Hash === dest then
+        dest, params, anchor = anchor, dest, params
+      end
+      utx = URLText.new mask_space: true
+      unless dest =~ %r{\A\w+://} then
+        dest = %Q'#{https? ? "https" : "http"}://#{http_host}#{fullpath dest}'
+      end
+      url = utx.mkurl dest, params, anchor
+      done { |res| res.headers.add "Location", url }
+    end
+
+    def fullpath dest
+      if dest then
+        dest =~ %r{\A/} || dest =~ /\.\w+\z/ ? dest : dest + ".rb"
+      else
+        File.basename script_name
+      end
+    end
+
+
+    if defined? MOD_RUBY then
+      # This has not been tested.
+      def query_string
+        Apache::request.args
+      end
+    end
+
+  end
+
+end
+