rims-rfc822 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 3721bb4e1b0e4865de80a3756bc313a910180b207c76bbe4e25de30c2bb14f0b
+  data.tar.gz: f1d6f3b4b1bc84d32644beeb89628c814be2b4674bc3e5c334ce2adcc8889a11
+SHA512:
+  metadata.gz: cb1a1894bed18cfc81da85627620de46d1754b8dc50145cc40de4af0c2ed9d5a75ea7cff508b889442b06c6a513c2d607824be15ec470e3718d203d150092c61
+  data.tar.gz: 42a2832fd4e246525c3e8932a7b7a1890b258862bb7adfd4077610cc8cf85fc05e277dfea02ecb93dea20f0b7894f31757a6ab5808fe626832f208099cefd453

data/.gitignore

@@ -0,0 +1,13 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+/vendor/
+/Gemfile.lock
+/README.html
+*~
+*.log

data/Gemfile

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in rims-rfc822.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2019 TOKI Yoshinori
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,74 @@
+RIMS::RFC822
+============
+
+Fast parser for a RFC822 formatted message.
+This gem is a component of RIMS (Ruby IMap Server), but can be used
+independently of RIMS.
+
+Installation
+------------
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'rims-rfc822'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install rims-rfc822
+
+Usage
+-----
+
+```ruby
+require 'rims/rfc822'
+
+msg = RIMS::RFC822::Message.new(your_rfc822_text)
+
+p msg.header
+p msg.body
+
+# source text attributes
+p msg.raw_source
+p msg.header.raw_source
+p msg.body.raw_source
+
+# type attributes
+p msg.media_main_type
+p msg.media_sub_type
+p msg.content_type
+p msg.content_type_parameters
+p msg.charset
+p msg.boundary
+
+# headear attributes
+p msg.date
+p msg.from
+p msg.sender
+p msg.reply_to
+p msg.to
+p msg.cc
+p msg.bcc
+
+# content attributes
+p msg.text?
+p msg.multipart?
+p msg.message?
+p msg.parts
+p msg.message
+```
+
+Contributing
+------------
+
+Bug reports and pull requests are welcome on GitHub at <https://github.com/y10k/rims-rfc822>.
+
+License
+-------
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,28 @@
+# -*- coding: utf-8 -*-
+
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+require 'rdoc/task'
+
+Rake::TestTask.new do |task|
+  if ((ENV.key? 'RUBY_DEBUG') && (! ENV['RUBY_DEBUG'].empty?)) then
+    task.ruby_opts << '-d'
+  end
+end
+
+Rake::RDocTask.new do |rd|
+  rd.rdoc_files.include('lib/**/*.rb')
+end
+
+desc 'Build README.html from markdown source'
+task :readme => %w[ README.html ]
+
+file 'README.html' => [ 'README.md' ] do
+  sh "pandoc --from=markdown --to=html5 --standalone --self-contained --css=$HOME/.pandoc/github.css --output=README.html README.md"
+end
+CLOBBER.include 'README.html'
+
+# Local Variables:
+# mode: Ruby
+# indent-tabs-mode: nil
+# End:

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "rims/rfc822"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/rims/rfc822/version.rb

@@ -0,0 +1,12 @@
+# -*- coding: utf-8 -*-
+
+module RIMS
+  module RFC822
+    VERSION = '0.1.0'
+  end
+end
+
+# Local Variables:
+# mode: Ruby
+# indent-tabs-mode: nil
+# End:

data/lib/rims/rfc822.rb

@@ -0,0 +1,464 @@
+# -*- coding: utf-8 -*-
+
+require 'rims/rfc822/version'
+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:

data/rims-rfc822.gemspec

@@ -0,0 +1,40 @@
+# -*- coding: utf-8 -*-
+
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'rims/rfc822/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'rims-rfc822'
+  spec.version       = RIMS::RFC822::VERSION
+  spec.authors       = ['TOKI Yoshinori']
+  spec.email         = ['toki@freedom.ne.jp']
+
+  spec.summary       = %q{Fast parser for a RFC822 formatted message.}
+  spec.description   = <<-'EOF'
+    Fast parser for a RFC822 formatted message.
+    This gem is a component of RIMS (Ruby IMap Server), but can be
+    used independently of RIMS.
+  EOF
+  spec.homepage      = 'https://github.com/y10k/rims-rfc822'
+  spec.license       = 'MIT'
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) {|f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler', '~> 1.17'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rdoc'
+  spec.add_development_dependency 'test-unit'
+end
+
+# Local Variables:
+# mode: Ruby
+# indent-tabs-mode: nil
+# End:

metadata

@@ -0,0 +1,112 @@
+--- !ruby/object:Gem::Specification
+name: rims-rfc822
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- TOKI Yoshinori
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2019-06-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.17'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.17'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  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'
+- !ruby/object:Gem::Dependency
+  name: test-unit
+  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
+      Fast parser for a RFC822 formatted message.
+      This gem is a component of RIMS (Ruby IMap Server), but can be
+      used independently of RIMS.
+email:
+- toki@freedom.ne.jp
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/rims/rfc822.rb
+- lib/rims/rfc822/version.rb
+- rims-rfc822.gemspec
+homepage: https://github.com/y10k/rims-rfc822
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3
+signing_key: 
+specification_version: 4
+summary: Fast parser for a RFC822 formatted message.
+test_files: []