hermeneutics 1.10 → 1.13

data/lib/hermeneutics/cli/pop3.rb

@@ -0,0 +1,257 @@
+#
+#  hermeneutics/cli/pop3.rb  --  POP3 client
+#
+
+require "hermeneutics/cli/protocol"
+
+module Hermeneutics
+
+  module Cli
+
+    class POP3 < Protocol
+
+      CRLF = true
+
+      PORT, PORT_SSL = 110, 995
+
+      class Error       < StandardError ; end
+      class UnspecError < Error         ; end
+      class AuthFail    < Error         ; end
+      class Check       < Error         ; end
+      class Unused      < Error         ; end
+
+      class <<self
+        private :new
+        def open host, port = nil, timeout: nil, ssl: false
+          port ||= ssl ? PORT_SSL : PORT
+          super host, port, timeout: timeout, ssl: ssl
+        end
+      end
+
+      attr_reader :last_response
+
+      def initialize *args
+        super
+        @stamp = get_response.slice /<[!-~]+@[!-~]+>/
+      end
+
+      def authenticate name, pwd
+        if @stamp then
+          apop name, pwd
+        else
+          user name
+          pass pwd
+        end
+      end
+
+      def user name
+        writeline "USER #{name}"
+        get_response
+      end
+
+      def pass pwd
+        writeline "PASS #{pwd}"
+        get_response_auth
+      end
+
+      def apop name, pwd
+        require "digest/md5"
+        hash = Digest::MD5.hexdigest "#@stamp#{pwd}"
+        writeline "APOP #{name} #{hash}"
+        get_response_auth
+      end
+
+      def capa
+        if block_given? then
+          writeline "CAPA"
+          get_response do |_|
+            get_data { |l|
+              c, *rest = l.split
+              yield c, rest
+            }
+          end
+        else
+          r = Hash.new do |h,k| h[k] = [] end
+          capa do |c,v|
+            if v.notempty? then
+              r[c].concat v
+            else
+              r[c] = true
+            end
+          end
+          r
+        end
+      end
+
+      def stat
+        if block_given? then
+          writeline "STAT"
+          n, r = split_num_len get_response
+          yield n, r
+        else
+          stat do |*a| a end
+        end
+      end
+
+      def list n = nil
+        n = n.to_i.nonzero?
+        if block_given? then
+          cmd = "LIST"
+          cmd << " #{n}" if n
+          writeline cmd
+          if n then
+            n_, len = split_num_len get_response
+            n == n_ or raise Check, "Wrong LIST response: #{n} <-> #{n_}"
+            yield n, len
+          else
+            get_response do |_|
+              get_data do |l|
+                n_, len = split_num_len l
+                yield n_, len
+              end
+            end
+          end
+        else
+          if n then
+            list n do |*a| a end
+          else
+            h = {}
+            list n do |n_,len|
+              h[ n_] = len
+            end
+            h
+          end
+        end
+      end
+
+      def uidl n = nil
+        n = n.to_i.nonzero?
+        if block_given? then
+          cmd = "UIDL"
+          cmd << " #{n}" if n
+          writeline cmd
+          if n then
+            n_, id = split_num get_response
+            n == n_ or raise Check, "Wrong UIDL response: #{n} <-> #{n_}"
+            yield n, id
+          else
+            get_response do |_|
+              get_data do |l|
+                n_, id = split_num l
+                yield n_, id
+              end
+            end
+          end
+        else
+          if n then
+            uidl n do |*a| a end
+          else
+            h = {}
+            uidl n do |n_,id|
+              h[ n_] = id
+            end
+            h
+          end
+        end
+      end
+
+      def retr n, &block
+        writeline "RETR #{n}"
+        get_response do |_|
+          get_data_str &block
+        end
+      end
+
+      def top n, x, &block
+        writeline "TOP #{n} #{x}"
+        get_response do |_|
+          get_data_str &block
+        end
+      end
+
+
+      def dele n
+        writeline "DELE #{n}"
+        get_response
+      end
+
+      def rset
+        writeline "RSET"
+        get_response
+      end
+
+      def noop
+        writeline "NOOP"
+        get_response
+      end
+
+      def quit
+        writeline "QUIT"
+        get_response
+      end
+
+      private
+
+      def get_response
+        r = readline
+        a = case r
+          when /^\+OK */  then @last_response = $'.notempty?
+          when /^\-ERR */ then raise Error, $'
+          else                 raise UnspecError, r
+        end
+        if block_given? then
+          yield a
+        else
+          a
+        end
+      ensure
+        unless done? then
+          r = readline
+          r and raise Unused, "Unexpected data: #{r.inspect}"
+        end
+      end
+
+      def get_response_auth
+        begin
+          get_response
+        rescue Error
+          err = $!.message
+        end
+        raise AuthFail, err if err
+      end
+
+      def get_data
+        loop do
+          l = readline
+          break if l == "."
+          l.slice /\A\./
+          yield l
+        end
+      end
+
+      def get_data_str
+        if block_given? then
+          get_data { |l| yield l }
+        else
+          r = ""
+          get_data { |l| r << l << "\n" }
+          r
+        end
+      end
+
+      def split_num str
+        n, r = str.split nil, 2
+        [ n.to_i, r]
+      end
+
+      def split_num_len str
+        n, r = split_num str
+        [ n, r.to_i]
+      end
+
+    end
+
+  end
+
+end
+

data/lib/hermeneutics/cli/protocol.rb

@@ -0,0 +1,141 @@
+#
+#  hermeneutics/cli/protocol.rb  --  Basic communication
+#
+
+require "supplement"
+require "socket"
+
+
+if RUBY_VERSION < "3" then
+  class TCPSocket
+    class <<self
+      alias open_orig open
+      def open host, port, connect_timeout: nil, &block
+        open_orig host, port, &block
+      end
+    end
+  end
+end
+
+module Hermeneutics
+
+  module Cli
+
+    class Protocol
+
+      class <<self
+        private :new
+        def open host, port, timeout: nil, ssl: false
+          open_socket host, port, timeout, ssl do |s|
+            i = new s, timeout
+            yield i
+          end
+        end
+        private
+        def open_socket host, port, timeout, ssl
+          TCPSocket.open host, port, connect_timeout: timeout do |s|
+            if ssl then
+              require "hermeneutics/cli/openssl"
+              if Hash === ssl then
+                if ssl[ :ca_file] || ssl[ :ca_path] then
+                  ssl[ :verify_mode] ||= OpenSSL::SSL::VERIFY_PEER
+                end
+              else
+                vfm = case ssl
+                  when true    then OpenSSL::SSL::VERIFY_NONE
+                  when Integer then ssl
+                  when :none   then OpenSSL::SSL::VERIFY_NONE
+                  when :peer   then OpenSSL::SSL::VERIFY_PEER
+                end
+                ssl = { verify_mode: vfm}
+              end
+              ctx = OpenSSL::SSL::SSLContext.new
+              ctx.set_params ssl
+              s = OpenSSL::SSL::SSLSocket.new s, ctx
+              s.connect
+            end
+            yield s
+          end
+        end
+      end
+
+      CRLF = false
+
+      attr_writer :timeout
+
+      def initialize socket, timeout
+        @socket, @timeout = socket, timeout
+      end
+
+      def trace!
+        @trace = true
+      end
+
+      def writeline l
+        l.chomp!
+        @trace and $stderr.puts "C: #{l}"
+        @socket.write l
+        @socket.write self.class::CRLF ? "\r\n" : "\n"
+      end
+
+      def readline
+        @socket.wait @timeout||0
+        r = @socket.readline
+        r.chomp!
+        @trace and $stderr.puts "S: #{r}"
+        r
+      rescue EOFError
+      end
+
+      def write data
+        @trace and $stderr.puts "C- #{data.inspect}"
+        @socket.write data
+      end
+
+      def read bytes
+        @socket.wait @timeout||0
+        r = @socket.read bytes
+        @trace and $stderr.puts "S- #{r.inspect}"
+        r
+      rescue EOFError
+      end
+
+      def done?
+        not @socket.ready?
+      end
+
+    end
+
+
+    module CramMD5
+
+      class <<self
+        def included cls
+          require "digest/md5"
+        end
+      end
+
+      private
+
+      def crammd5_answer a
+        "#@user #{hmac_md5 a, @passwd}"
+      end
+
+      MASKS = [ 0x36, 0x5c, ]
+      IMASK, OMASK = *MASKS
+
+      def hmac_md5 text, key
+        key = Digest::MD5.digest key if key.length > 64
+        nulls = [ 0]*64
+        k_ip, k_op = *MASKS.map { |m|
+          (nulls.zip key.bytes).map { |n,k| ((k||n) ^ m).chr }.join
+        }
+        Digest::MD5.hexdigest k_op + (Digest::MD5.digest k_ip + text)
+      end
+
+    end
+
+  end
+
+end
+

data/lib/hermeneutics/cli/smtp.rb

@@ -0,0 +1,218 @@
+#
+#  hermeneutics/cli/smtp.rb  --  SMTP client
+#
+
+require "hermeneutics/cli/protocol"
+
+module Hermeneutics
+
+  module Cli
+
+    class SMTP < Protocol
+
+      CRLF = true
+
+      PORT, PORT_SSL = 25, 465
+
+      class Error           < StandardError ; end
+      class UnspecError     < Error         ; end
+      class ServerNotReady  < Error         ; end
+      class NotOk           < Error         ; end
+      class NotReadyForData < Error         ; end
+      class Unused          < Error         ; end
+      class Uncaught        < Error         ; end
+
+      class <<self
+        private :new
+        def open host, port = nil, timeout: nil, ssl: false
+          port ||= ssl ? PORT_SSL : PORT
+          super host, port, timeout: timeout, ssl: ssl
+        end
+      end
+
+      attr_reader :domain, :greet
+      attr_reader :advertised
+      attr_reader :last_response
+
+      def initialize *args
+        super
+        get_response.ok? or raise ServerNotReady, @last_response.msg
+      end
+
+      def size
+        @advertised && @advertised[ :SIZE]
+      end
+
+      def auth
+        @advertised && @advertised[ :AUTH]
+      end
+
+      def has_auth? meth
+        a = auth
+        a and a.include? meth
+      end
+
+
+      def helo host = nil
+        cmd_hello "HELO", host
+      end
+
+      def ehlo host = nil
+        @advertised = {}
+        cmd_hello "EHLO", host do |code,msg|
+          unless @domain then
+            @domain, @greet = msg.split nil, 2
+            next
+          end
+          keyword, param = msg.split nil, 2
+          keyword.upcase!
+          keyword = keyword.to_sym
+          case keyword
+            when :SIZE then param = Integer param
+            when :AUTH then param = param.split.map { |p| p.upcase! ; p.to_sym }
+          end
+          @advertised[ keyword] = param || true
+        end
+      end
+
+      def mail_from from
+        cmd "MAIL", "FROM:<#{from}>"
+      end
+
+      def rcpt_to to
+        cmd "RCPT", "TO:<#{to}>"
+      end
+
+      def data reader
+        write_cmd "DATA"
+        get_response.waiting? or raise NotReadyForData, @last_response.msg
+        reader.each_line { |l|
+          l =~ /\A\./ and l = ".#{l}"
+          writeline l
+        }
+        writeline "."
+        get_response_ok
+      end
+
+      def bdat data
+        data.each { |d|
+          write_cmd "BDAT", d.bytesize
+          write d
+          get_response_ok
+        }
+        write_cmd "BDAT", 0, "LAST"
+        get_response_ok do |code,msg|
+          yield msg if block_given?
+        end
+      end
+
+      def rset
+        cmd "RSET"
+      end
+
+      def help str = nil, &block
+        cmd "HELP", str, &block
+      end
+
+      def noop str = nil
+        cmd "NOOP"
+      end
+
+      def quit
+        cmd "QUIT"
+      end
+
+
+      def plain user, password
+        write_cmd "AUTH", "PLAIN"
+        get_response.waiting? or raise NotReadyForData, @last_response.msg
+        l = ["\0#{user}\0#{password}"].pack "m0"
+        writeline l
+        get_response_ok
+      end
+
+
+      def login user, password
+        write_cmd "AUTH", "LOGIN"
+        get_response.waiting? or raise NotReadyForData, @last_response.msg
+        writeline [user].pack "m0"
+        get_response.waiting? or raise NotReadyForData, @last_response.msg
+        writeline [password].pack "m0"
+        get_response_ok
+      end
+
+
+      private
+
+      def cmd_hello name, host, &block
+        host ||= Socket.gethostname
+        write_cmd name, host
+        get_response_ok &block
+        unless @domain then
+          @domain, @greet = @last_response.msg.split nil, 2
+        end
+      end
+
+      def cmd name, *args, &block
+        write_cmd name, *args
+        get_response_ok &block
+      end
+
+      def write_cmd name, *args
+        l = [ name, *args].join " "
+        writeline l
+      end
+
+      class Response
+
+        attr_reader :code, :msg
+
+        def initialize code, msg
+          @code, @msg = code, msg
+        end
+
+        def kat ; code / 100 ; end
+
+        def to_s ; "%03d %s" % [ @code, @msg] ; end
+
+        def prelim?  ; kat == 1 ; end
+        def ok?      ; kat == 2 ; end
+        def waiting? ; kat == 3 ; end
+        def error?   ; kat == 4 ; end
+        def fatal?   ; kat == 5 ; end
+
+      end
+
+      def get_response_ok &block
+        get_response &block
+        @last_response.ok? or raise NotOk, @last_response.msg
+        true
+      end
+
+      def get_response
+        loop do
+          r = readline
+          if r =~ /\A(\d\d\d) / then
+            @last_response = Response.new $1.to_i, $'
+            break
+          elsif r =~ /\A(\d\d\d)-/ then
+            block_given? or raise Uncaught, r
+            yield $1.to_i, $'
+          else
+            raise UnspecError, r
+          end
+        end
+        @last_response
+      ensure
+        unless done? then
+          r = readline
+          r and raise Unused, "Unexpected data: #{r.inspect}"
+        end
+      end
+
+    end
+
+  end
+
+end
+

data/lib/hermeneutics/color.rb

@@ -8,7 +8,7 @@
 
 Hermeneutics::Color handles 24-bit colors.
 
-Hermeneutics::Colour is an alias for <code>Hermeneutics::Color</code>.
+Hermeneutics::Colour is an alias for +Hermeneutics::Color+.
 
 =end
 
@@ -41,7 +41,7 @@ module Hermeneutics
     #   new( r, g, b)           -> clr
     #
     # Create a color with red, green and blue values.  They are in range
-    # <code>0..255</code>.
+    # +0..255+.
     #
     def initialize r, *gb
       if gb.any? then
@@ -79,8 +79,8 @@ module Hermeneutics
       # :call-seq:
       #   gray( num)           -> clr
       #
-      # Create a gray color (r=b=g). <code>num</code> is in range
-      # <code>0..255</code>.
+      # Create a gray color (r=b=g). +num+ is in range
+      # +0..255+.
       #
       def gray i
         new i, i, i
@@ -96,7 +96,7 @@ module Hermeneutics
     #
     def to_s ; "#" + tuple.map { |x| "%02x" % x }.join ; end
 
-    def inspect ; "#<#{cls}:#{'0x%08x' % (object_id << 1)} #{to_s}>" ; end
+    def inspect ; "#<#{self.class}:#{'0x%08x' % (object_id << 1)} #{to_s}>" ; end
 
     class <<self
 
@@ -224,8 +224,8 @@ module Hermeneutics
     # :call-seq:
     #   edit_hsv() { |h,s,v| ... }    -> clr
     #
-    # Convert it to an HSV triple, yield that to the block and build a
-    # new <code>Color</code> from the blocks result.
+    # Convert it to an HSV triple, yield that to the block and build a new
+    # +Color+ from the blocks result.
     #
     def edit_hsv
       hsv = yield *to_hsv
@@ -241,19 +241,26 @@ module Hermeneutics
 
   end
 
-  # Alias for class <code>Hermeneutics::Color</code> in British English.
+  # Alias for class +Hermeneutics::Color+ in British English.
   Colour = Color
 
 end
 
 
-class Float
+class Integer
   def to_gray
     Hermeneutics::Color.gray self
   end
   alias to_grey to_gray
 end
 
+class Float
+  def to_gray
+    (0xff * self).to_i.to_gray
+  end
+  alias to_grey to_gray
+end
+
 class String
   def to_gray
     (Integer self).to_gray

data/lib/hermeneutics/contents.rb

@@ -115,6 +115,9 @@ module Hermeneutics
       end
     end
 
+    def empty?    ; @hash.empty?            ; end
+    def notempty? ; self if @hash.notempty? ; end
+
     # :call-seq:
     #   []( key)      -> str or nil
     #
@@ -123,6 +126,8 @@ module Hermeneutics
     def [] key ; @hash[ key.to_sym] ; end
     alias field []
 
+    private
+
     def method_missing sym, *args
       if sym =~ /[^a-z_]/ or args.any? then
         super
@@ -131,6 +136,8 @@ module Hermeneutics
       end
     end
 
+    public
+
     # :call-seq:
     #   keys()       -> ary
     #
@@ -252,6 +259,9 @@ module Hermeneutics
       super hash
     end
 
+    def empty?    ; @caption.empty? and super           ; end
+    def notempty? ; self if @caption.notempty? or super ; end
+
     def =~ re
       @caption =~ re
     end