hermeneutics 1.8

data/lib/hermeneutics/cli/pop.rb

@@ -0,0 +1,102 @@
+#
+#  hermeneutics/cli/pop.rb  --  POP client
+#
+
+module Hermeneutics
+
+  module Cli
+
+    class Pop
+
+      class Keep < Exception ; end
+
+      def initialize host, port = nil
+        if not port and host =~ /:(\d+)\z/ then
+          host, port = $`, $1.to_i
+        end
+        @host, @port = host, port
+        require "net/pop"
+      end
+
+      def login user, password
+        do_apop do
+          @pop = Net::POP3.new @host, @port, @apop
+          do_ssl
+          @pop.start user, password do |pop|
+            @user = user
+            yield
+          end
+        end
+      ensure
+        @user = nil
+      end
+
+      def name
+        @user or raise "Not logged in."
+        r = "#@user@#@host"
+        r << ":#@port" if @port
+        r
+      end
+
+      def count ; @pop.n_mails ; end
+
+      def each
+        @pop.mails.each do |m|
+          begin
+            yield m.pop
+            m.delete
+          rescue Keep
+          end
+        end
+      end
+
+      private
+
+      def do_apop
+        @apop = true
+        begin
+          yield
+        rescue Net::POPAuthenticationError
+          raise unless @apop
+          @apop = false
+          retry
+        end
+      end
+
+      def do_ssl
+        @pop.disable_ssl
+      end
+
+    end
+
+    class Pops < Pop
+
+      def initialize host, port = nil, certs = nil
+        unless certs or Integer === port then
+          port, certs = nil, port
+        end
+        @certs = File.expand_path certs if certs
+        super host, port
+      end
+
+      private
+
+      def do_apop
+        yield
+      end
+
+      def do_ssl
+        v = if @certs then
+          OpenSSL::SSL::VERIFY_PEER
+        else
+          OpenSSL::SSL::VERIFY_NONE
+        end
+        @pop.enable_ssl v, @certs
+      end
+
+    end
+
+  end
+
+end
+

data/lib/hermeneutics/color.rb

@@ -0,0 +1,275 @@
+#
+#  hermeneutics/color.rb  -- Color calculation
+#
+
+=begin rdoc
+
+:section: Classes definied here
+
+Hermeneutics::Color handles 24-bit colors.
+
+Hermeneutics::Colour is an alias for <code>Hermeneutics::Color</code>.
+
+=end
+
+
+
+module Hermeneutics
+
+  # Generate HTML color values.
+  #
+  # = Examples
+  #
+  #   red = Color.new 0xff, 0, 0
+  #   black = Color.grey 0
+  #   red.to_s                           #=> "#ff0000"
+  #   red.to_fract                       #=> [ 1.0, 0.0, 0.0]
+  #
+  #   (Color.new 0xff, 0, 0).to_hsv      #=> [0.0, 1.0, 1.0]
+  #   (Color.new 0, 0xff, 0).to_hsv      #=> [120.0, 1.0, 1.0]
+  #   (Color.new 0, 0x7f, 0x7f).to_hsv   #=> [180.0, 1.0, 0.49804]
+  #   (Color.new 0, 0x80, 0x80).to_hsv   #=> [180.0, 1.0, 0.50196]
+  #   (Color.from_hsv 180, 1, 0.5).to_s  #=> "#007f7f"
+  #
+  class Color
+
+    attr_reader :r, :g, :b
+
+    private
+
+    # :call-seq:
+    #   new( r, g, b)           -> clr
+    #
+    # Create a color with red, green and blue values.  They are in range
+    # <code>0..255</code>.
+    #
+    def initialize r, *gb
+      if gb.any? then
+        @r, @g, @b = *[ r, *gb].map { |x| ff x }
+      else
+        @r = @g = @b = (ff r)
+      end
+    end
+
+    def ff x ; (Integer x) & 0xff ; end
+
+    public
+
+    def r= x ; @r = ff x ; end
+    def g= x ; @g = ff x ; end
+    def b= x ; @b = ff x ; end
+
+    # :call-seq:
+    #   to_a()    -> ary
+    #
+    # Return RGB values as an array.
+    #
+    def to_a ; [ @r, @g, @b] ; end
+    alias tuple to_a
+
+    def == oth
+      case oth
+        when Color then to_a == oth.to_a
+        when Array then to_a == oth
+      end
+    end
+
+    class <<self
+
+      # :call-seq:
+      #   gray( num)           -> clr
+      #
+      # Create a gray color (r=b=g). <code>num</code> is in range
+      # <code>0..255</code>.
+      #
+      def gray i
+        new i, i, i
+      end
+      alias grey gray
+
+    end
+
+    # :call-seq:
+    #   to_s()    -> str
+    #
+    # Return color as an HTML tags key.
+    #
+    def to_s ; "#" + tuple.map { |x| "%02x" % x }.join ; end
+
+    def inspect ; "#<#{cls}:#{'0x%08x' % (object_id << 1)} #{to_s}>" ; end
+
+    class <<self
+
+      # :call-seq:
+      #   from_s( str)    -> clr
+      #
+      # Build a Color from an HTML tags key.
+      #
+      def from_s str
+        rgb = str.scan( /[0-9a-f]{2}/i).map do |x| x.to_i 0x10 end
+        new *rgb
+      end
+
+    end
+
+
+    # :call-seq:
+    #   to_fract()    -> ary
+    #
+    # Return three values in range 0..1 where 1.0 means 255.
+    #
+    def to_fract
+      tuple.map { |x| x / 255.0 }
+    end
+
+    class <<self
+
+      # :call-seq:
+      #   from_fract( rf, gf, bf)    -> clr
+      #
+      # Build a Color from three values in range 0..1 where 1.0 means 255.
+      #
+      def from_fract rf, gf, bf
+        rgb = [rf, gf, bf].map { |x| 0xff * x }
+        new *rgb
+      end
+
+    end
+
+
+    # :call-seq:
+    #   to_long()    -> ary
+    #
+    # Extend it to a 48-bit color triple.
+    #
+    def to_long
+      tuple.map { |x| x * 0x100 + x }
+    end
+
+    class <<self
+
+      # :call-seq:
+      #   from_fract( rl, gl, bl)    -> clr
+      #
+      # Build a Color from three values in range 0..0xffff.
+      #
+      def from_long rl, gl, bl
+        rgb = [rl, gl, bl].map { |x| x / 0x100 }
+        new *rgb
+      end
+
+    end
+
+
+    # :call-seq:
+    #   to_hsv()    -> ary
+    #
+    # Convert it to an HSV triple.
+    #
+    def to_hsv
+      rgb = [ @r, @g, @b].map { |x| (Integer x) / 255.0 }
+      v = rgb.max
+      delta = v - rgb.min
+      unless delta > 0.0 then
+        h = s = 0.0
+      else
+        s = delta / v
+        r, g, b = rgb
+        case v
+          when r then h =     (g - b) / delta ; h += 6 if h < 0
+          when g then h = 2 + (b - r) / delta
+          when b then h = 4 + (r - g) / delta
+        end
+        h *= 60
+      end
+      [ h, s, v]
+    end
+
+    class <<self
+
+      # :call-seq:
+      #   from_hsv( h, s, v)    -> clr
+      #
+      # Build a Color from HSV parameters.
+      #
+      # Ranges are:
+      #
+      #   h    0...360
+      #   s    0.0..1.0
+      #   v    0.0..1.0
+      #
+      def from_hsv h, s, v
+        if s.nonzero? then
+          h /= 60.0
+          i = h.to_i % 6
+          f = h - i
+          rgb = []
+          if (i%2).zero? then
+            rgb.push v
+            rgb.push v * (1.0 - s * (1.0 - f))
+          else
+            rgb.push v * (1.0 - s * f)
+            rgb.push v
+          end
+          rgb.push v * (1.0 - s)
+          rgb.rotate! -(i/2)
+          from_fract *rgb
+        else
+          from_fract v, v, v
+        end
+      end
+
+    end
+
+    # :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.
+    #
+    def edit_hsv
+      hsv = yield *to_hsv
+      self.class.from_hsv *hsv
+    end
+
+    # :call-seq:
+    #   complementary()                -> clr
+    #
+    # Build the complementary color.
+    #
+    def complementary ; Color.new *(tuple.map { |x| 0xff - x }) ; end
+
+  end
+
+  # Alias for class <code>Hermeneutics::Color</code> in British English.
+  Colour = Color
+
+end
+
+
+class Float
+  def to_gray
+    Hermeneutics::Color.gray self
+  end
+  alias to_grey to_gray
+end
+
+class String
+  def to_gray
+    (Integer self).to_gray
+  end
+  alias to_grey to_gray
+  def to_rgb
+    Hermeneutics::Color.from_s self
+  end
+end
+
+class Array
+  def to_rgb
+    Hermeneutics::Color.new *self
+  end
+  def to_hsv
+    Hermeneutics::Color.from_hsv *self
+  end
+end
+

data/lib/hermeneutics/contents.rb

@@ -0,0 +1,351 @@
+#
+#  hermeneutics/contents.rb  --  Handle header fields like Content-Type
+#
+
+=begin rdoc
+
+:section: Classes definied here
+
+Hermeneutics::Contents is a content field parser.
+
+Hermeneutics::ContentType parses "Content-Type" header fields.
+
+=end
+
+require "hermeneutics/escape"
+
+
+module Hermeneutics
+
+  # A parser for header fields like DKIM-Signature
+  #
+  # === Example
+  #
+  #   ds = Dictionary.new v: 1, a: "rsa-sha256", c: "relaxed/relaxed", ...
+  #
+  #   ds = Dictionary.parse "v=1; a=rsa-sha256; c=relaxed/relaxed; ..."
+  #   ds[ "a"]  #=> "0123456"
+  #
+  class Dictionary
+
+    # :stopdoc:
+    SEP = ";"
+    SEA = "="
+    RES = /#{SEP}\s*/
+    REA = /((?:\*(\d+))?\*)?#{SEA}/
+    # :startdoc:
+
+    class <<self
+
+      # Create a +Dictionary+ object out of a string from a
+      # mail header field.
+      #
+      #   ds = Dictionary.parse "v=1; a=rsa-sha256; c=relaxed/relaxed; ..."
+      #   ds[ "a"]  #=> "0123456"
+      #
+      def parse line
+        rest = line.strip
+        hash = parse_hash rest
+        new hash
+      end
+
+      def urltext
+        @urltext ||= URLText.new mask_space: true
+      end
+
+      private
+
+      def parse_hash rest
+        hash = Hash.new { |h,k| h[ k] = [] }
+        asts = {}
+        while rest.notempty? do
+          key, rest = if rest =~ REA then
+            ast = $1
+            ord = $2.to_i if $2
+            [ $`, $']
+          else
+            [ rest.dup, ""]
+          end
+          key.downcase!
+          key = key.to_sym
+          asts[ key] = ast
+          val, rest = if not ast and rest =~ /\A"(.*?)"(?:#{SEP}\s*|\z)/ then
+            [ $1, $']
+          else
+            rest.split RES, 2
+          end
+          if ord then
+            hash[ key][ ord] = val
+          else
+            hash[ key] = val
+          end
+        end
+        r = URLText::Dict.new
+        hash.keys.each { |k|
+          v = hash[ k]
+          Array === v and v = v.join
+          if asts[ k] then
+            enc, lang, val = v.split "'"
+            val.force_encoding enc
+            v = URLText.decode val
+          end
+          r[ k] = v
+        }
+        r
+      end
+
+    end
+
+    attr_reader :hash
+    alias to_hash hash
+    alias to_h to_hash
+
+    # Create a +Dictionary+ object from a value and a hash.
+    #
+    #   ds = Dictionary.new :v => 1, :a => "rsa-sha256",
+    #                               :c => "relaxed/relaxed", ...
+    #
+    def initialize hash = nil
+      case hash
+        when URLText::Dict then
+          @hash = hash
+        else
+          @hash = URLText::Dict.new
+          @hash.merge! hash if hash
+      end
+    end
+
+    # :call-seq:
+    #   []( key)      -> str or nil
+    #
+    # Find value of +key+.
+    #
+    def [] key ; @hash[ key.to_sym] ; end
+    alias field []
+
+    def method_missing sym, *args
+      if sym =~ /[^a-z_]/ or args.any? then
+        super
+      else
+        field sym
+      end
+    end
+
+    # :call-seq:
+    #   keys()       -> ary
+    #
+    # Returns a list of all contained keys
+    #
+    #   c = Contents.new "text/html; boundary=0123456"
+    #   c.keys                #=> [ :boundary]
+    #
+    def keys ; @hash.keys ; end
+
+
+    # :stopdoc:
+    TSPECIAL = %r_[()<>@,;:\\"\[\]/?=]_    # RFC 1521
+    # :startdoc:
+
+    # Show the line as readable text.
+    #
+    def to_s
+      quoted_parts.join "#{SEP} "
+    end
+    alias quote to_s
+
+    private
+    def quoted_parts
+      @hash.map { |k,v|
+        case v
+          when true                            then v = k
+          when false                           then v = nil
+          when TSPECIAL, /\s/, /[\0-\x1f\x7f]/ then v = v.inspect
+        end
+        "#{k}=#{v}"
+      }
+    end
+    public
+
+    # Encode it for a mail header field.
+    #
+    def encode
+      f, *rest = encoded_parts
+      if f then
+        r = [ f]
+        rest.each { |e|
+          r.last << SEP
+          r.push e
+        }
+      end
+      r
+    end
+
+    private
+    def encoded_parts
+      r = @hash.map { |k,v|
+        case v
+          when nil    then next
+          when true   then v = k
+          when false  then v = ""
+          when String then nil
+          else             v = v.to_s
+        end
+        if not v.ascii_only? or v =~ /[=;"]/ then
+          enc = v.encoding
+          if (l = ENV[ "LANG"]) then
+            l, = l.split /\W/, 2
+            lang = l.gsub "_", "-"
+          end
+          v = [ enc, lang, (Dictionary.urltext.encode v)].join "'"
+        end
+        "#{k}=#{v}"
+      }
+      r.compact!
+      r
+    end
+    public
+
+  end
+
+  # A parser for header fields in Content-Type style
+  #
+  # === Example
+  #
+  #   content_disposition = Contents.new "form-data", :name => "mycontrol"
+  #
+  #   content_type = Contents.parse "text/html; boundary=0123456"
+  #   content_type.caption       #=>  "text/html"
+  #   content_type[ :boundary]   #=> "0123456"
+  #     # (Subclass ContentType even splits the caption into type/subtype.)
+  #
+  class Contents < Dictionary
+
+    class <<self
+
+      # Create a +Contents+ object out of a string from a
+      # mail header field.
+      #
+      #   c = Contents.parse "text/html; boundary=0123456"
+      #   c.caption         #=> "text/html"
+      #   c[ :boundary]     #=> "0123456"
+      #
+      def parse line
+        rest = line.strip
+        caption, rest = rest.split Dictionary::RES, 2
+        hash = parse_hash rest
+        new caption, hash
+      end
+
+    end
+
+    attr_reader :caption
+
+    # Create a +Contents+ object from a value and a hash.
+    #
+    #   c = Contents.new "text/html", :boundary => "0123456"
+    #
+    def initialize caption, hash = nil
+      if caption =~ RES or caption =~ REA then
+        raise "Invalid content caption '#{caption}'."
+      end
+      @caption = caption.new_string
+      super hash
+    end
+
+    def =~ re
+      @caption =~ re
+    end
+
+
+    def quoted_parts
+      r = [ "#@caption"]
+      r.concat super
+      r
+    end
+
+    def encoded_parts
+      r = [ "#@caption"]
+      r.concat super
+      r
+    end
+
+  end
+
+  class ContentType < Contents
+
+    # :call-seq:
+    #   new( str)      -> cts
+    #
+    # Create a +ContentType+ object either out of a string from an
+    # E-Mail header field or from a value and a hash.
+    #
+    #   c = ContentType.parse "text/html; boundary=0123456"
+    #   c = ContentType.new "text/html", :boundary => "0123456"
+    #
+    def initialize line, sf = nil
+      line = line.join "/" if Array === line
+      super
+    end
+
+    # :call-seq:
+    #   split_type      -> str
+    #
+    # Find caption value of Content-Type style header field as an array
+    #
+    #   c = ContentType.new "text/html; boundary=0123456"
+    #   c.split_type       #=>  [ "text", "html"]
+    #   c.type           #=>  "text"
+    #   c.subtype        #=>  "html"
+    #
+    def split_type ; @split ||= (@caption.split "/", 2) ; end
+
+    # :call-seq:
+    #   fulltype      -> str
+    #
+    # Find caption value of Content-Type style header field.
+    #
+    #   c = ContentType.new "text/html; boundary=0123456"
+    #   c.fulltype       #=>  "text/html"
+    #   c.type           #=>  "text"
+    #   c.subtype        #=>  "html"
+    #
+    def fulltype ; caption ; end
+
+    # :call-seq:
+    #   type      -> str
+    #
+    # See +fulltype+ or +split_type+.
+    #
+    def type    ; split_type.first ; end
+
+    # :call-seq:
+    #   subtype      -> str
+    #
+    # See +fulltype+ or +split_type+.
+    #
+    def subtype ; split_type.last  ; end
+
+    def parse_mime input
+      m = Mime.find @caption
+      m and m.parse input, @hash
+    end
+
+  end
+
+  class Mime
+    @types = []
+    class <<self
+      def inherited cls
+        Mime.types.push cls
+      end
+      protected
+      attr_reader :types
+      public
+      def find type
+        Mime.types.find { |t| t::MIME === type }
+      end
+    end
+  end
+
+end
+