rims 0.2.5 → 0.3.0

data/test/test_service.rb

@@ -446,6 +446,14 @@ module RIMS::Test
       assert_equal(expected_value, @c.daemon_debug?)
     end
 
+    data('default' => [ 0037, {} ],
+         'umask'   => [ 0022, { daemon: { umask: 0022 } } ])
+    def test_daemon_umask(data)
+      expected_value, config = data
+      @c.load(config)
+      assert_equal(expected_value, @c.daemon_umask)
+    end
+
     data('default'  => [ File.join(BASE_DIR, 'rims.pid'), {} ],
          'rel_path' => [ File.join(BASE_DIR, 'status'),   { daemon: { status_file: 'status' } } ],
          'abs_path' => [ '/var/run/rims.pid',             { daemon: { status_file: '/var/run/rims.pid' } } ])
@@ -709,6 +717,133 @@ module RIMS::Test
       assert_equal(expected_values, limits.to_h)
     end
 
+    data('default' => [ 1024 * 8,  {} ],
+         'config'  => [ 1024 * 16, { protocol: { line_length_limit: 1024 * 16 } } ])
+    def test_protocol_line_length_limit(data)
+      expected_value, config = data
+      @c.load(config)
+      assert_equal(expected_value, @c.protocol_line_length_limit)
+    end
+
+    data('default' => [ 1024**2 * 10, {} ],
+         'config'  => [ 1024**2 * 16, { protocol: { literal_size_limit: 1024**2 * 16 } } ])
+    def test_protocol_literal_size_limit(data)
+      expected_value, config = data
+      @c.load(config)
+      assert_equal(expected_value, @c.protocol_literal_size_limit)
+    end
+
+    data('default' => [ 1024**2 * 10, {} ],
+         'config'  => [ 1024**2 * 16, { protocol: { command_size_limit: 1024**2 * 16  } } ])
+    def test_protocol_command_size_limit(data)
+      expected_value, config = data
+      @c.load(config)
+      assert_equal(expected_value, @c.protocol_command_size_limit)
+    end
+
+    data('default'                 => [ [ [ 'EUC-JP',      Encoding::EUCJP_MS ],
+                                          [ 'ISO-2022-JP', Encoding::CP50221 ],
+                                          [ 'SHIFT_JIS',   Encoding::WINDOWS_31J ]
+                                        ],
+                                        {}
+                                      ],
+         'use_default_aliases:yes' => [ [ [ 'EUC-JP',      Encoding::EUCJP_MS ],
+                                          [ 'ISO-2022-JP', Encoding::CP50221 ],
+                                          [ 'SHIFT_JIS',   Encoding::WINDOWS_31J ]
+                                        ],
+                                        { charset: {
+                                            use_default_aliases: true
+                                          }
+                                        }
+                                      ],
+         'use_default_aliases:no'  => [ [],
+                                        { charset: {
+                                            use_default_aliases: false
+                                          }
+                                        }
+                                      ],
+         'aliases'                 => [ [ [ 'EUC-JP',      Encoding::EUCJP_MS ],
+                                          [ 'SHIFT_JIS',   Encoding::WINDOWS_31J ]
+                                        ],
+                                        { charset: {
+                                            use_default_aliases: false,
+                                            aliases: [
+                                              { name: 'euc-jp',    encoding: 'eucJP-ms' },
+                                              { name: 'Shift_JIS', encoding: 'Windows-31J' }
+                                            ]
+                                          }
+                                        }
+                                      ])
+    def test_charset_aliases(data)
+      expected_aliases, config = data
+      @c.load(config)
+      assert_equal(expected_aliases, @c.charset_aliases.to_a)
+    end
+
+    data('default'                              => [ { undef: :replace }, {} ],
+         'replace_invalid_byte_sequence: true'  => [ { invalid: :replace,
+                                                       undef: :replace
+                                                     },
+                                                     { charset: {
+                                                         convert_options: {
+                                                           replace_invalid_byte_sequence: true
+                                                         }
+                                                       }
+                                                     }
+                                                   ],
+         'replace_invalid_byte_sequence: false' => [ { undef: :replace },
+                                                     { charset: {
+                                                         convert_options: {
+                                                           replace_invalid_byte_sequence: false
+                                                         }
+                                                       }
+                                                     }
+                                                   ],
+         'replace_undefined_character: true'    => [ { undef: :replace },
+                                                     { charset: {
+                                                         convert_options: {
+                                                           replace_undefined_character: true
+                                                         }
+                                                       }
+                                                     }
+                                                   ],
+         'replace_undefined_character: false'   => [ {},
+                                                     { charset: {
+                                                         convert_options: {
+                                                           replace_undefined_character: false
+                                                         }
+                                                       }
+                                                     }
+                                                   ],
+         'replaced_mark'                        => [ { undef: :replace,
+                                                       replace: "\uFFFD"
+                                                     },
+                                                     { charset: {
+                                                         convert_options: {
+                                                           replaced_mark: "\uFFFD"
+                                                         }
+                                                       }
+                                                     }
+                                                   ],
+         'all'                                  => [ { invalid: :replace,
+                                                       undef: :replace,
+                                                       replace: "\uFFFD"
+                                                     },
+                                                     { charset: {
+                                                         convert_options: {
+                                                           replace_invalid_byte_sequence: true,
+                                                           replace_undefined_character: true,
+                                                           replaced_mark: "\uFFFD"
+                                                         }
+                                                       }
+                                                     }
+                                                   ])
+    def test_charset_convert_options(data)
+      expected_options, config = data
+      @c.load(config)
+      assert_equal(expected_options, @c.charset_convert_options)
+    end
+
     data('default' => [ 0, {} ],
          'config'  => [ 4,
                         { drb_services: {
@@ -722,6 +857,21 @@ module RIMS::Test
       assert_equal(expected_value, @c.drb_process_num)
     end
 
+    data('default'    => [ {}, {}, {} ],
+         'load_limit' => [ { load_limit: 134217728 },
+                           { load_limit: 134217728 },
+                           { drb_services: {
+                               load_limit: 134217728
+                             }
+                           }
+                         ])
+    def test_drb_server_client_config(data)
+      expected_server_config, expected_client_config, config = data
+      @c.load(config)
+      assert_equal(expected_server_config, @c.drb_server_config)
+      assert_equal(expected_client_config, @c.drb_client_config)
+    end
+
     data('default' => [ 100, {} ],
          'config'  => [ 1024,
                         { drb_services: {
@@ -737,6 +887,21 @@ module RIMS::Test
       assert_equal(expected_value, @c.bulk_response_count)
     end
 
+    data('default' => [ 1024**2 * 10, {} ],
+         'config'  => [ 33554432,
+                        { drb_services: {
+                            engine: {
+                              bulk_response_size: 33554432
+                            }
+                          }
+                        }
+                      ])
+    def test_bulk_response_size(data)
+      expected_value, config = data
+      @c.load(config)
+      assert_equal(expected_value, @c.bulk_response_size)
+    end
+
     data('default'  => [ 30, {} ],
          'config'   => [ 15,
                          { drb_services: {

metadata

@@ -1,29 +1,43 @@
 --- !ruby/object:Gem::Specification
 name: rims
 version: !ruby/object:Gem::Version
-  version: 0.2.5
+  version: 0.3.0
 platform: ruby
 authors:
 - TOKI Yoshinori
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-06-10 00:00:00.000000000 Z
+date: 2020-08-28 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: rims-rfc822
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.2.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.2.2
 - !ruby/object:Gem::Dependency
   name: riser
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.1.8
+        version: 0.2.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.1.8
+        version: 0.2.0
 - !ruby/object:Gem::Dependency
   name: logger-joint
   requirement: !ruby/object:Gem::Requirement
@@ -94,6 +108,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: irb
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: |2
       RIMS is Ruby IMap Server.
       This gem provides a complete IMAP server by itself.  The IMAP
@@ -107,6 +135,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
+- CHANGELOG.md
 - ChangeLog
 - Gemfile
 - LICENSE.txt
@@ -130,7 +159,6 @@ files:
 - lib/rims/protocol/connection.rb
 - lib/rims/protocol/decoder.rb
 - lib/rims/protocol/parser.rb
-- lib/rims/rfc822.rb
 - lib/rims/service.rb
 - lib/rims/test.rb
 - lib/rims/version.rb
@@ -156,7 +184,6 @@ files:
 - test/test_protocol_fetch.rb
 - test/test_protocol_request.rb
 - test/test_protocol_search.rb
-- test/test_rfc822.rb
 - test/test_service.rb
 homepage: https://github.com/y10k/rims
 licenses:
@@ -177,7 +204,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4
 summary: RIMS is Ruby IMap Server
@@ -202,5 +229,4 @@ test_files:
 - test/test_protocol_fetch.rb
 - test/test_protocol_request.rb
 - test/test_protocol_search.rb
-- test/test_rfc822.rb
 - test/test_service.rb

data/lib/rims/rfc822.rb

@@ -1,463 +0,0 @@
-# -*- coding: utf-8 -*-
-
-require 'time'
-
-module RIMS
-  module RFC822
-    def split_message(msg_txt)
-      header_txt, body_txt = msg_txt.lstrip.split(/\r?\n\r?\n/, 2)
-      header_txt << $& if $&
-      [ header_txt, body_txt ]
-    end
-    module_function :split_message
-
-    def parse_header(header_txt)
-      field_pair_list = header_txt.scan(%r{
-        ^
-        ((?#name) \S+? )
-        \s* : \s*
-        (
-           (?#value)
-           .*? (?: \n|\z)
-           (?: ^\s .*? (?: \n|\z) )*
-        )
-      }x)
-
-      for _name, value in field_pair_list
-        value.strip!
-        name.freeze
-        value.freeze
-      end
-
-      field_pair_list.freeze
-    end
-    module_function :parse_header
-
-    def parse_content_type(content_type_txt)
-      src_txt = content_type_txt.dup
-      if (src_txt.sub!(%r"\A \s* (?<main_type>\S+?) \s* / \s* (?<sub_type>\S+?) \s* (?:;|\Z)"x, '')) then
-        main_type = $~[:main_type]
-        sub_type = $~[:sub_type]
-
-        params = {}
-        src_txt.scan(%r'(?<name>\S+?) \s* = \s* (?: (?<quoted_string>".*?") | (?<token>\S+?) ) \s* (?:;|\Z)'x) do
-          name = $~[:name]
-          if ($~[:quoted_string]) then
-            quoted_value = $~[:quoted_string]
-            value = unquote_phrase(quoted_value)
-          else
-            value = $~[:token]
-          end
-          params[name.downcase] = [ name.freeze, value.freeze ].freeze
-        end
-
-        [ main_type.freeze, sub_type.freeze, params.freeze ].freeze
-      else
-        [ 'application'.freeze, 'octet-stream'.freeze, {}.freeze ].freeze
-      end
-    end
-    module_function :parse_content_type
-
-    def parse_multipart_body(boundary, body_txt)
-      delim = '--' + boundary
-      term = delim + '--'
-      body_txt2, _body_epilogue_txt = body_txt.split(term, 2)
-      if (body_txt2) then
-        _body_preamble_txt, body_parts_txt = body_txt2.split(delim, 2)
-        if (body_parts_txt) then
-          part_list = body_parts_txt.split(delim, -1)
-          for part_txt in part_list
-            part_txt.lstrip!
-            part_txt.chomp!("\n")
-            part_txt.chomp!("\r")
-            part_txt.freeze
-          end
-          return part_list.freeze
-        end
-      end
-
-      [].freeze
-    end
-    module_function :parse_multipart_body
-
-    def unquote_phrase(phrase_txt)
-      state = :raw
-      src_txt = phrase_txt.dup
-      dst_txt = ''.encode(phrase_txt.encoding)
-
-      while (src_txt.sub!(/\A(:? " | \( | \) | \\ | [^"\(\)\\]+ )/x, ''))
-        match_txt = $&
-        case (state)
-        when :raw
-          case (match_txt)
-          when '"'
-            state = :quote
-          when '('
-            state = :comment
-          when "\\"
-            src_txt.sub!(/\A./, '') and dst_txt << $&
-          else
-            dst_txt << match_txt
-          end
-        when :quote
-          case (match_txt)
-          when '"'
-            state = :raw
-          when "\\"
-            src_txt.sub!(/\A./, '') && dst_txt << $&
-          else
-            dst_txt << match_txt
-          end
-        when :comment
-          case (match_txt)
-          when ')'
-            state = :raw
-          when "\\"
-            src_txt.sub!(/\A./, '')
-          else
-            # ignore comment text.
-          end
-        else
-          raise "internal error: unknown state #{state}"
-        end
-      end
-
-      dst_txt.freeze
-    end
-    module_function :unquote_phrase
-
-    def parse_mail_address_list(address_list_txt)
-      addr_list = []
-      src_txt = address_list_txt.dup
-
-      while (true)
-        if (src_txt.sub!(%r{
-              \A
-              \s*
-              (?<display_name>\S.*?) \s* : (?<group_list>.*?) ;
-              \s*
-              ,?
-            }x, ''))
-        then
-          display_name = $~[:display_name]
-          group_list = $~[:group_list]
-          addr_list << [ nil, nil, unquote_phrase(display_name), nil ].freeze
-          addr_list.concat(parse_mail_address_list(group_list))
-          addr_list << [ nil, nil, nil, nil ].freeze
-        elsif (src_txt.sub!(%r{
-                 \A
-                 \s*
-                 (?<local_part>[^<>@",\s]+) \s* @ \s* (?<domain>[^<>@",\s]+)
-                 \s*
-                 ,?
-               }x, ''))
-        then
-          addr_list << [ nil, nil, $~[:local_part].freeze, $~[:domain].freeze ].freeze
-        elsif (src_txt.sub!(%r{
-                 \A
-                 \s*
-                 (?<display_name>\S.*?)
-                 \s*
-                 <
-                   \s*
-                   (?:
-                     (?<route>@[^<>@",]* (?:, \s* @[^<>@",]*)*)
-                     \s*
-                     :
-                   )?
-                   \s*
-                   (?<local_part>[^<>@",\s]+) \s* @ \s* (?<domain>[^<>@",\s]+)
-                   \s*
-                 >
-                 \s*
-                 ,?
-               }x, ''))
-        then
-          display_name = $~[:display_name]
-          route = $~[:route]
-          local_part = $~[:local_part]
-          domain = $~[:domain]
-          addr_list << [ unquote_phrase(display_name), route.freeze, local_part.freeze, domain.freeze ].freeze
-        else
-          break
-        end
-      end
-
-      addr_list.freeze
-    end
-    module_function :parse_mail_address_list
-
-    class Header
-      include Enumerable
-
-      def initialize(header_txt)
-        @raw_source = header_txt.freeze
-        @field_list = nil
-        @field_map = nil
-      end
-
-      attr_reader :raw_source
-
-      def setup_header
-        if (@field_list.nil? || @field_map.nil?) then
-          @field_list = RFC822.parse_header(@raw_source)
-          @field_map = {}
-          for name, value in @field_list
-            key = name.downcase
-            @field_map[key] = [] unless (@field_map.key? key)
-            @field_map[key] << value
-          end
-          @field_map.each_value do |value_list|
-            value_list.freeze
-          end
-          @field_map.freeze
-          self
-        end
-      end
-      private :setup_header
-
-      def each
-        setup_header
-        return enum_for(:each) unless block_given?
-        for name, value in @field_list
-          yield(name, value)
-        end
-        self
-      end
-
-      def key?(name)
-        setup_header
-        @field_map.key? name.downcase
-      end
-
-      def [](name)
-        setup_header
-        if (value_list = @field_map[name.downcase]) then
-          value_list[0]
-        end
-      end
-
-      def fetch_upcase(name)
-        setup_header
-        if (value_list = @field_map[name.downcase]) then
-          if (value = value_list[0]) then
-            value.upcase
-          end
-        end
-      end
-
-      def field_value_list(name)
-        setup_header
-        @field_map[name.downcase]
-      end
-    end
-
-    class Body
-      def initialize(body_txt)
-        @raw_source = body_txt.freeze
-      end
-
-      attr_reader :raw_source
-    end
-
-    class Message
-      def initialize(msg_txt)
-        @raw_source = msg_txt.freeze
-        @header = nil
-        @body = nil
-        @content_type = nil
-        @is_multipart = nil
-        @parts = nil
-        @is_message = nil
-        @message = nil
-        @date = nil
-        @from = nil
-        @sender = nil
-        @reply_to = nil
-        @to = nil
-        @cc = nil
-        @bcc = nil
-      end
-
-      attr_reader :raw_source
-
-      def setup_message
-        if (@header.nil? || @body.nil?) then
-          header_txt, body_txt = RFC822.split_message(@raw_source)
-          @header = Header.new(header_txt || '')
-          @body = Body.new(body_txt || '')
-          self
-        end
-      end
-      private :setup_message
-
-      def header
-        setup_message
-        @header
-      end
-
-      def body
-        setup_message
-        @body
-      end
-
-      def setup_content_type
-        if (@content_type.nil?) then
-          @content_type = RFC822.parse_content_type(header['content-type'] || '')
-          self
-        end
-      end
-      private :setup_content_type
-
-      def to_upper(text_or_nil)
-        text_or_nil.upcase if text_or_nil
-      end
-      private :to_upper
-
-      def media_main_type
-        setup_content_type
-        @content_type[0]
-      end
-
-      def media_main_type_upcase
-        setup_content_type
-        to_upper(@content_type[0])
-      end
-
-      def media_sub_type
-        setup_content_type
-        @content_type[1]
-      end
-
-      def media_sub_type_upcase
-        setup_content_type
-        to_upper(@content_type[1])
-      end
-
-      def content_type
-        "#{media_main_type}/#{media_sub_type}"
-      end
-
-      def content_type_upcase
-        to_upper("#{media_main_type}/#{media_sub_type}")
-      end
-
-      def content_type_parameters
-        setup_content_type
-        @content_type[2].each_value.map{|name, value| [ name, value ] }
-      end
-
-      def charset
-        setup_content_type
-        if (name_value_pair = @content_type[2]['charset']) then
-          name_value_pair[1]
-        end
-      end
-
-      def boundary
-        setup_content_type
-        if (name_value_pair = @content_type[2]['boundary']) then
-          name_value_pair[1]
-        end
-      end
-
-      def text?
-        media_main_type_upcase == 'TEXT'
-      end
-
-      def multipart?
-        if (@is_multipart.nil?) then
-          @is_multipart = (media_main_type_upcase == 'MULTIPART')
-        end
-        @is_multipart
-      end
-
-      def parts
-        if (multipart?) then
-          if (@parts.nil?) then
-            if (boundary = self.boundary) then
-              part_list = RFC822.parse_multipart_body(boundary, body.raw_source)
-              @parts = part_list.map{|msg_txt| Message.new(msg_txt) }.freeze
-            else
-              @parts = [].freeze
-            end
-          end
-          @parts
-        end
-      end
-
-      def message?
-        if (@is_message.nil?) then
-          @is_message = (media_main_type_upcase == 'MESSAGE')
-        end
-        @is_message
-      end
-
-      def message
-        if (message?) then
-          if (@message.nil?) then
-            @message = Message.new(body.raw_source)
-          end
-          @message
-        end
-      end
-
-      def date
-        if (header.key? 'Date') then
-          if (@date.nil?) then
-            begin
-              @date = Time.parse(header['Date'])
-            rescue ArgumentError
-              @date = Time.at(0)
-            end
-          end
-
-          @date.freeze
-        end
-      end
-
-      def mail_address_header_field(field_name)
-        if (header.key? field_name) then
-          ivar_name = '@' + field_name.downcase.gsub('-', '_')
-          addr_list = instance_variable_get(ivar_name)
-          if (addr_list.nil?) then
-            addr_list = header.field_value_list(field_name).map{|addr_list_str| RFC822.parse_mail_address_list(addr_list_str) }.inject(:+)
-            addr_list.freeze
-            instance_variable_set(ivar_name, addr_list)
-          end
-          addr_list
-        end
-      end
-      private :mail_address_header_field
-
-      def from
-        mail_address_header_field('from')
-      end
-
-      def sender
-        mail_address_header_field('sender')
-      end
-
-      def reply_to
-        mail_address_header_field('reply-to')
-      end
-
-      def to
-        mail_address_header_field('to')
-      end
-
-      def cc
-        mail_address_header_field('cc')
-      end
-
-      def bcc
-        mail_address_header_field('bcc')
-      end
-    end
-  end
-end
-
-# Local Variables:
-# mode: Ruby
-# indent-tabs-mode: nil
-# End: