hermeneutics 1.11 → 1.14

data/lib/hermeneutics/message.rb

@@ -7,57 +7,6 @@ require "hermeneutics/contents"
 require "hermeneutics/addrs"
 
 
-class NilClass
-  def eat_lines
-  end
-  def rewind
-  end
-end
-class String
-  def eat_lines
-    @pos ||= 0
-    while @pos < length do
-      p = index /.*\n?/, @pos
-      l = $&.length
-      begin
-        yield self[ @pos, l]
-      ensure
-        @pos += l
-      end
-    end
-  end
-  def rewind
-    @pos = 0
-  end
-end
-class Array
-  def eat_lines &block
-    @pos ||= 0
-    while @pos < length do
-      begin
-        self[ @pos].eat_lines &block
-      ensure
-        @pos += 1
-      end
-    end
-  end
-  def rewind
-    each { |e| e.rewind }
-    @pos = 0
-  end
-end
-class IO
-  def eat_lines &block
-    each_line &block
-    nil
-  end
-  def to_s
-    rewind
-    read
-  end
-end
-
-
 module Hermeneutics
 
   class Multipart < Mime
@@ -67,65 +16,6 @@ module Hermeneutics
     class IllegalBoundary < StandardError ; end
     class ParseError      < StandardError ; end
 
-    # :stopdoc:
-    class PartFile
-      class <<self
-        def open file, sep
-          i = new file, sep
-          yield i
-        end
-        private :new
-      end
-      public
-      attr_reader :prolog, :epilog
-      def initialize file, sep
-        @file = file
-        @sep = /^--#{Regexp.quote sep}(--)?/
-        read_part
-        @prolog = norm_nl @a
-      end
-      def next_part
-        return if @epilog
-        read_part
-        @a.first.chomp!
-        true
-      end
-      def eat_lines
-        yield @a.pop while @a.any?
-      end
-      private
-      def read_part
-        @a = []
-        e = nil
-        @file.eat_lines { |l|
-          l =~ @sep rescue nil
-          if $& then
-            e = [ $'] if $1
-            @a.reverse!
-            return
-          end
-          @a.push l
-        }
-        raise ParseError, "Missing separator #@sep"
-      ensure
-        if e then
-          @file.eat_lines { |l| e.push l }
-          e.reverse!
-          @epilog = norm_nl e
-        end
-      end
-      def norm_nl a
-        r = ""
-        while a.any? do
-          l = a.pop
-          l.chomp! and l << $/
-          r << l
-        end
-        r
-      end
-    end
-    # :startdoc:
-
     public
 
     class <<self
@@ -133,14 +23,16 @@ module Hermeneutics
       def parse input, **parameters
         b = parameters[ :boundary]
         b or raise ParseError, "Missing boundary parameter."
-        PartFile.open input, b do |partfile|
-          list = []
-          while partfile.next_part do
-            m = Message.parse partfile
-            list.push m
-          end
-          new b, partfile.prolog, list, partfile.epilog
-        end
+        input.encode! input.encoding, universal_newline: true
+        list = input.split /^--#{Regexp.quote b}/
+        prolog = list.shift
+        epilog = list.pop
+        epilog and epilog.slice! /\A--\n/ or raise "Missing last separator."
+        list.each { |p|
+          p.slice! /\A\n/ or raise "Malformed separator: #{b + p[/.*/]}."
+        }
+        list.map! { |t| Message.parse t }
+        new b, prolog, list, epilog
       end
 
     end
@@ -164,7 +56,7 @@ module Hermeneutics
 
     def inspect
       r = ""
-      r << "#<#{cls}:"
+      r << "#<#{self.class}:"
       r << "0x%x" % (object_id<<1)
       r << " n=#{@list.length}"
       r << ">"
@@ -181,10 +73,10 @@ module Hermeneutics
         s = p.to_s
         s =~ re rescue nil
         $& and raise IllegalBoundary
-        r << splitter << $/ << s << $/
+        r << splitter << "\n" << s
       }
       @epilog =~ re and raise IllegalBoundary
-      r << splitter << "--" << @epilog
+      r << splitter << "--\n" << @epilog
     rescue IllegalBoundary
       boundary!
       retry
@@ -209,111 +101,140 @@ module Hermeneutics
 
     class ParseError < StandardError ; end
 
-    class Headers
+    class Header
 
-      class Entry
-        LINE_LENGTH = 78
-        INDENT = "    "
-        class <<self
-          private :new
-          def parse str
-            str =~ /:\s*/ or
-              raise ParseError, "Header line without a colon: #{str}"
-            data = $'
-            new $`, $&, data
-          end
-          def create name, *contents
-            name = build_name name
-            i = new name.to_s, ": ", nil
-            i.set *contents
-          end
-          def build_name name
-            n = name.to_s
-            unless n.equal? name then
-              n.gsub! /_/, "-"
-              n.gsub! /\b[a-z]/ do |c| c.upcase end
-            end
-            n
-          end
+      @line_max = 78
+      @indent   = 4
+
+      class <<self
+
+        attr_accessor :line_max, :indent
+
+        private :new
+
+        def parse str
+          str =~ /:\s*/ or
+            raise ParseError, "Header line without a colon: #{str}"
+          new $`, $'
         end
-        attr_reader :name, :sep, :data
-        def initialize name, sep, data
-          @name, @sep, @data, @contents = name, sep, data
+
+        def create name, *contents
+          name = build_name name
+          i = new name.to_s, nil
+          i.set *contents
         end
-        def to_s
-          "#@name#@sep#@data"
+
+        def build_name name
+          n = name.to_s
+          unless n.equal? name then
+            n.gsub! /_/, "-"
+            n.gsub! /\b[a-z]/ do |c| c.upcase end
+          end
+          n
         end
-        def contents type
-          if type then
-            unless @contents and @contents.is_a? type then
+
+      end
+
+      attr_reader :name, :data
+
+      def initialize name, data
+        @name, @data, @contents = name, data
+      end
+
+      def to_s
+        "#@name: #@data"
+      end
+
+      def contents type = nil
+        if type then
+          if @contents then
+            if not @contents.is_a? type then
               @contents = type.parse @data
             end
-            @contents
           else
-            @data
-          end
-        end
-        def name_is? name
-          (@name.casecmp name).zero?
-        end
-        def set *contents
-          type, *args = *contents
-          d = case type
-            when Class then
-              @contents = type.new *args
-              case (e = @contents.encode)
-                when Array then e
-                when nil   then []
-                else            [ e]
-              end
-            when nil then
-              @contents = nil
-              split_args args
-            else
-              @contents = nil
-              split_args contents
+            @contents = type.parse @data
           end
-          @data = mk_lines d
-          self
-        end
-        def reset type
-          if type then
-            c = contents type
-            @data = mk_lines c.encode if c
+        else
+          unless @contents then
+            @contents = @data
+            @contents.strip!
+            @contents.gsub! /\s\+/m, " "
           end
-          self
         end
-        private
-        def mk_lines strs
-          m = LINE_LENGTH - @name.length - @sep.length
-          data = ""
-          strs.each { |e|
-            unless data.empty? then
-              if 1 + e.length <= m then
-                data << " "
-                m -= 1
-              else
-                data << $/ << INDENT
-                m = LINE_LENGTH - INDENT.length
-              end
+        @contents
+      end
+
+      def name_is? name
+        (@name.casecmp name).zero?
+      end
+
+      def set *contents
+        type, *args = *contents
+        d = case type
+          when Class then
+            @contents = type.new *args
+            case (e = @contents.encode)
+              when Array then e
+              when nil   then []
+              else            [ e]
             end
-            data << e
-            m -= e.length
-          }
-          data
+          when nil then
+            @contents = nil
+            split_args args
+          else
+            @contents = nil
+            split_args contents
         end
-        def split_args ary
-          r = []
-          ary.each { |a|
-            r.concat case a
-              when Array then split_args a
-              else            a.to_s.split
-            end
-          }
-          r
+        @data = mk_lines d
+        self
+      end
+
+      def reset type
+        d = if type then
+          (contents type).encode
+        else
+          @contents
         end
+        @data = mk_lines d
+        self
       end
 
+      private
+
+      def mk_lines strs
+        m = self.class.line_max - @name.length - 2  # 2 == ": ".size
+        data = ""
+        strs.each { |e|
+          unless data.empty? then
+            if 1 + e.length <= m then
+              data << " "
+              m -= 1
+            else
+              data << "\n" << (" "*self.class.indent)
+              m = self.class.line_max - self.class.indent
+            end
+          end
+          data << e
+          m -= e.length
+        }
+        data
+      end
+
+      def split_args ary
+        r = []
+        ary.each { |a|
+          r.concat case a
+            when Array then split_args a
+            else            a.to_s.split
+          end
+        }
+        r
+      end
+
+    end
+
+    class Headers
+
       @types = {
         "Content-Type"        => ContentType,
         "To"                  => AddrList,
@@ -345,7 +266,7 @@ module Hermeneutics
 
       class <<self
         def set_field_type name, type
-          e = Entry.create name
+          e = Header.create name
           if type then
             @types[ e.name] = type
           else
@@ -364,7 +285,7 @@ module Hermeneutics
         private :new
         def parse *list
           list.flatten!
-          list.map! { |h| Entry.parse h }
+          list.map! { |h| Header.parse h }
           new list
         end
         def create
@@ -382,17 +303,28 @@ module Hermeneutics
       alias size length
 
       def to_s
-        @list.map { |e| "#{e}#$/" }.join
+        @list.map { |e| "#{e}\n" }.join
+      end
+
+      private
+
+      def header_contents entry, type = nil
+        type ||= Headers.find_type entry
+        entry.contents type
       end
 
+      public
+
       def each
-        @list.each { |e|
-          type = Headers.find_type e
-          c = e.contents type
-          yield e.name, c
-        }
+        @list.each { |e| yield e.name, (header_contents e) }
         self
       end
+      include Enumerable
+
+      def has? name
+        e = find_entry name
+        not e.nil?
+      end
 
       def raw name
         e = find_entry name
@@ -401,10 +333,7 @@ module Hermeneutics
 
       def field name, type = nil
         e = find_entry name
-        if e then
-          type ||= Headers.find_type e
-          e.contents type
-        end
+        header_contents e, type if e
       end
       def [] name, type = nil
         case name
@@ -415,9 +344,9 @@ module Hermeneutics
 
       private
 
-      def method_missing sym, *args
+      def method_missing sym, type = nil, *args
         if args.empty? and not sym =~ /[!?=]\z/ then
-          field sym, *args
+          field sym, type
         else
           super
         end
@@ -425,28 +354,80 @@ module Hermeneutics
 
       public
 
-      def add name, *contents
+      def insert name, *contents
         e = build_entry name, *contents
-        add_entry e
+        @list.unshift e
         self
       end
 
-      def replace name, *contents
+      def add name, *contents
         e = build_entry name, *contents
-        remove_entries e
-        add_entry e
+        @list.push e
         self
       end
 
-      def remove name
-        e = Entry.create name
-        remove_entries e
+      def remove name, type = nil
+        block_given? or return remove name, type do |_| true end
+        pat = Header.create name
+        @list.reject! { |e|
+          e.name_is? pat.name and yield (header_contents e, type)
+        }
         self
       end
       alias delete remove
 
+      def compact name, type = nil
+        remove name, type do |c| c.empty? end
+      end
+      alias remove_empty compact
+
+      def replace name, *contents
+        block_given? or return replace name, *contents do true end
+        entry = build_entry name, *contents
+        @list.map! { |e|
+          if e.name_is? entry.name and yield (header_contents e) then
+            entry
+          else
+            e
+          end
+        }
+        self
+      end
+
+      def replace_all name, type = nil
+        pat = Header.create name
+        type ||= Headers.find_type pat
+        @list.map! { |e|
+          if e.name_is? pat.name then
+            c = e.contents type
+            y = yield c
+            if y.equal? c then
+              e.reset type
+            else
+              y = [ type, *y] if type
+              next build_entry name, *y
+            end
+          end
+          e
+        }
+        self
+      end
+
+      def replace_add name, *contents
+        entry = build_entry name, *contents
+        replace_all name do |c|
+          if entry then
+            c.push entry.contents
+            entry = nil
+          end
+          c
+        end
+        @list.push entry if entry
+        self
+      end
+
       def recode name, type = nil
-        n = Entry.build_name name
+        n = Header.build_name name
         @list.each { |e|
           next unless e.name_is? n
           type ||= Headers.find_type e
@@ -457,7 +438,7 @@ module Hermeneutics
 
       def inspect
         r = ""
-        r << "#<#{cls}:"
+        r << "#<#{self.class}:"
         r << "0x%x" % (object_id<<1)
         r << " (#{length})"
         r << ">"
@@ -466,12 +447,12 @@ module Hermeneutics
       private
 
       def find_entry name
-        e = Entry.build_name name
+        e = Header.build_name name
         @list.find { |x| x.name_is? e }
       end
 
       def build_entry name, *contents
-        e = Entry.create name
+        e = Header.create name
         type, = *contents
         case type
           when Class then
@@ -483,14 +464,6 @@ module Hermeneutics
         e
       end
 
-      def add_entry entry
-        @list.unshift entry
-      end
-
-      def remove_entries entry
-        @list.reject! { |e| e.name_is? entry.name }
-      end
-
     end
 
     class <<self
@@ -510,12 +483,13 @@ module Hermeneutics
       private
 
       def parse_hb input
-        h = parse_headers input
+        hinput, input = input.split /^\n/, 2
+        h = parse_headers hinput
         c = h.content_type
         b = c.parse_mime input if c
         unless b then
           b = ""
-          input.eat_lines { |l| b << l }
+          input.each_line { |l| b << l }
           b
         end
         yield h, b
@@ -523,7 +497,7 @@ module Hermeneutics
 
       def parse_headers input
         h = []
-        input.eat_lines { |l|
+        input.each_line { |l|
           l.chomp!
           case l
             when /^$/ then
@@ -531,7 +505,7 @@ module Hermeneutics
             when /^\s+/ then
               h.last or
                 raise ParseError, "First line may not be a continuation."
-              h.last << $/ << l
+              h.last << "\n" << l
             else
               h.push l
           end
@@ -548,19 +522,28 @@ module Hermeneutics
       @headers ||= Headers.create
     end
 
+    def header sym, type = nil
+      @headers.field sym, type
+    end
+
     private
 
     def method_missing sym, *args, &block
       case sym
-        when /h_(.*)/, /header_(.*)/ then
-          @headers.field $1.to_sym, *args
+        when /\Ah_(.*)/, /\Aheader_(.*)/ then
+          header $1.to_sym, *args
         else
-          @headers.field sym, *args or super
+          super
       end
     end
 
     public
 
+    def has? name
+      @headers.has? name
+    end
+    alias has_header? has?
+
     def [] name, type = nil
       @headers[ name, type]
     end
@@ -572,7 +555,7 @@ module Hermeneutics
 
     def inspect
       r = ""
-      r << "#<#{cls}:"
+      r << "#<#{self.class}:"
       r << "0x%x" % (object_id<<1)
       r << " headers:#{@headers.length}"
       r << " multipart" if is_multipart?
@@ -588,7 +571,8 @@ module Hermeneutics
           @headers.replace :content_type, c.fulltype, boundary: u
         end
       end
-      r << @headers.to_s << $/ << @body.to_s
+      r << @headers.to_s << "\n" << @body.to_s
+      r.ends_with? "\n" or r << "\n"
       r
     end