imap_mogura 0.1.1.pre.dev

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 63948c26de8c10fedd38588189779fd6eeee167f3ab8fe54be42ab3ae37eac76
+  data.tar.gz: 1b86c8501895ea103f4627a34cb3057eda23f42d0722aeceb2d6ea1630ed7472
+SHA512:
+  metadata.gz: 902ce048023623971dd7c26e5512888eea1275e1160895f8fa0d6a36d91386f76e8f5d3f3a3b2cef42709b0d76d77bd08cf8c4381ea03d4dbaa62a9691b25b82
+  data.tar.gz: 72055ee14145ec3a81ccfe02f50bc903f060368e933fbce27e63f0d45ffdd5f0ec1829ffa054ec4f0179d77bec9f4948c4dc372d408943f1332f7973b81e12ef

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,21 @@
+AllCops:
+  TargetRubyVersion: 3.0
+  NewCops: enable
+
+Gemspec/RequireMFA:
+  Enabled: false
+
+Layout/LineLength:
+  Enabled: false
+
+Metrics:
+  Enabled: false
+
+Style/Documentation:
+  Enabled: false
+
+Style/StringLiterals:
+  EnforcedStyle: double_quotes
+
+Style/StringLiteralsInInterpolation:
+  EnforcedStyle: double_quotes

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2024 ysk
+
+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,78 @@
+# ImapMogura
+
+A mail filtering tool for IMAP.
+
+## Installation
+
+Check out this repository first and enter the directory.
+
+```console
+$ git clone https://github.com/yskuniv/imap_mogura.git
+$ cd imap_mogura/
+```
+
+Install this gem and add to the application's Gemfile by executing:
+
+    $ bundle install
+
+## Usage
+
+Create `rules.yml` and write rules like following.
+
+```yaml
+rules:
+  - destination: test
+    rule:
+      and:
+        - subject: "^\\[TEST "
+        - or:
+          - sender: "test@example\\.com"
+          - x-test: "X-TEST"
+
+  - destination: bar
+    rule:
+      from: "no-reply@bar\\.example\\.com"
+
+  - destination: Trash
+    rule:
+      subject: "i'm trash-like email!!"
+```
+
+As following, `start` command will start monitoring RECENT mails on "INBOX". If a mail is coming
+ and it's RECENT, it will be filtered.
+
+```console
+$ mogura start <host> -u <user> --password-base64=<password-base64-encoded> -c rules.yml -b INBOX
+```
+
+You can specify a mailbox which to be monitored by `-b` option.
+
+If you want to just filter mails on a specific mailbox, run the `filter` command as following.
+
+```console
+$ mogura filter <host> -u <user> --password-base64=<password-base64-encoded> -c rules.yml -b <mailbox>
+```
+
+You can check your config by `check-config` command. It returns just OK if no errors in the config.
+
+```console
+$ mogura check-config -c rules.yml
+OK
+$ 
+```
+
+About more features, see `--help`.
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/yskuniv/imap_mogura.
+
+## 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,12 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new
+
+task default: %i[spec rubocop]

data/exe/mogura

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+# frozen_string_literal: true
+
+require "imap_mogura"
+
+ImapMogura::CLI.start(ARGV)

data/lib/imap_mogura/cli.rb

@@ -0,0 +1,264 @@
+# frozen_string_literal: true
+
+require "thor"
+require "base64"
+
+module ImapMogura
+  class CustomOptionError < Thor::Error
+    def initialize(msg = "Custom option error message")
+      super
+    end
+  end
+
+  class CLI < Thor
+    class << self
+      def exit_on_failure?
+        true
+      end
+    end
+
+    desc "start HOST", "connect to HOST and start watching"
+    option :port, type: :numeric, default: 143, aliases: :p
+    option :starttls, type: :boolean, default: true
+    option :use_ssl, type: :boolean, default: false
+    option :auth_type, type: :string, default: "LOGIN"
+    option :user, type: :string, aliases: :u
+    option :password_base64, type: :string
+    option :config, type: :string, aliases: :c, required: true
+    option :target_mailbox, type: :string, aliases: :b, required: true
+    option :filter_unseen, type: :boolean, default: true
+    option :create_directory, type: :boolean, default: true
+    option :dry_run, type: :boolean, default: false
+    def start(host)
+      port = options[:port]
+      starttls = options[:starttls]
+      use_ssl = options[:use_ssl]
+      auth_type = options[:auth_type] if use_ssl
+      user = options[:user]
+      password = Base64.decode64(options[:password_base64])
+      config_name = options[:config]
+      target_mailbox = options[:target_mailbox]
+      filter_unseen = options[:filter_unseen]
+      create_directory = options[:create_directory]
+      dry_run = options[:dry_run]
+
+      monitored_events = ["RECENT"]
+      search_keys = ["RECENT", *(["UNSEEN"] if filter_unseen)]
+
+      with_all_preparation_ready(config_name, host, port, starttls, use_ssl,
+                                 auth_info: { auth_type: auth_type, user: user, password: password },
+                                 create_directory: create_directory,
+                                 dry_run: dry_run) do |imap_handler, rules|
+        warn "* start monitoring recent mails in \"#{target_mailbox}\""
+
+        imap_handler.monitor_events(target_mailbox, monitored_events) do
+          imap_handler.find_and_handle_mails(target_mailbox, search_keys) do |message_id|
+            warn "mail (id = #{message_id} on \"#{target_mailbox}\") is recent"
+
+            filter_mail(imap_handler, rules, target_mailbox, message_id, dry_run: dry_run)
+          end
+        end
+      end
+    end
+
+    desc "filter HOST", "filter mails on HOST"
+    option :port, type: :numeric, default: 143, aliases: :p
+    option :starttls, type: :boolean, default: true
+    option :use_ssl, type: :boolean, default: false
+    option :auth_type, type: :string, default: "LOGIN"
+    option :user, type: :string, aliases: :u
+    option :password_base64, type: :string
+    option :config, type: :string, aliases: :c, required: true
+    option :all_mailbox, type: :boolean, default: false, aliases: :a
+    option :exclude_mailboxes, type: :array, default: []
+    option :target_mailbox, type: :string, aliases: :b
+    option :filter_only_unseen, type: :boolean, default: false
+    option :create_directory, type: :boolean, default: true
+    option :dry_run, type: :boolean, default: false
+    def filter(host)
+      port = options[:port]
+      starttls = options[:starttls]
+      use_ssl = options[:use_ssl]
+      auth_type = options[:auth_type] if use_ssl
+      user = options[:user]
+      password = Base64.decode64(options[:password_base64])
+      config_name = options[:config]
+      all_mailbox = options[:all_mailbox]
+      exclude_mailboxes = options[:exclude_mailboxes]
+      target_mailbox = options[:target_mailbox] unless all_mailbox
+
+      raise CustomOptionError, "--all-mailbox (-a) or --target-mailbox (-b) is required" if !all_mailbox && target_mailbox.nil?
+
+      filter_only_unseen = options[:filter_only_unseen]
+      create_directory = options[:create_directory]
+      dry_run = options[:dry_run]
+
+      search_keys = if filter_only_unseen
+                      ["UNSEEN"]
+                    else
+                      ["ALL"]
+                    end
+
+      with_all_preparation_ready(config_name, host, port, starttls, use_ssl,
+                                 auth_info: { auth_type: auth_type, user: user, password: password },
+                                 excluded_mailboxes: exclude_mailboxes,
+                                 create_directory: create_directory,
+                                 dry_run: dry_run) do |imap_handler, rules, options|
+        if all_mailbox
+          excluded_mailboxes = options[:excluded_mailboxes]
+
+          imap_handler.all_mailbox_list.reject { |mailbox| excluded_mailboxes.include?(mailbox) }.each do |mailbox|
+            filter_mails(imap_handler, rules, mailbox, search_keys, dry_run: dry_run)
+          end
+        else
+          filter_mails(imap_handler, rules, target_mailbox, search_keys, dry_run: dry_run)
+        end
+      end
+    end
+
+    desc "list HOST", "list mailboxes on HOST"
+    option :port, type: :numeric, default: 143, aliases: :p
+    option :starttls, type: :boolean, default: true
+    option :use_ssl, type: :boolean, default: false
+    option :auth_type, type: :string, default: "LOGIN"
+    option :user, type: :string, aliases: :u
+    option :password_base64, type: :string
+    def list(host)
+      port = options[:port]
+      starttls = options[:starttls]
+      use_ssl = options[:use_ssl]
+      auth_type = options[:auth_type] if use_ssl
+      user = options[:user]
+      password = Base64.decode64(options[:password_base64])
+
+      imap_handler = IMAPHandler.new(host, port,
+                                     starttls: starttls, usessl: use_ssl, certs: nil, verify: true,
+                                     auth_info: { auth_type: auth_type, user: user, password: password })
+
+      puts imap_handler.all_mailbox_list
+
+      imap_handler.close
+    end
+
+    desc "check-config", "check config specified by --config / -c"
+    option :config, type: :string, aliases: :c, required: true
+    def check_config
+      config_name = options[:config]
+
+      load_and_handle_config(config_name)
+
+      warn "OK"
+    end
+
+    private
+
+    def with_all_preparation_ready(config_name,
+                                   host, port,
+                                   starttls, use_ssl, certs: nil, verify: true,
+                                   auth_info: nil,
+                                   excluded_mailboxes: [],
+                                   create_directory: true,
+                                   dry_run: false, &block)
+      _, rules = load_and_handle_config(config_name)
+
+      warn "* connecting the server #{host}:#{port}..."
+
+      imap_handler = IMAPHandler.new(host, port,
+                                     starttls: starttls, usessl: use_ssl, certs: certs, verify: verify,
+                                     auth_info: auth_info)
+
+      # FIXME: this doesn't work expectedly
+      # trap("INT") do
+      #   imap_handler.close
+      #   exit
+      # end
+
+      touch_all_mailboxes_in_rules(imap_handler, rules, dry_run: dry_run) if create_directory
+
+      options = { excluded_mailboxes: excluded_mailboxes }
+
+      block[imap_handler, rules, options]
+
+      imap_handler.close
+    end
+
+    def load_and_handle_config(config_name)
+      metadata, raw_rules = ConfigParser.parse(config_name)
+
+      rules = RulesParser.parse(raw_rules)
+
+      [metadata, rules]
+    rescue ConfigParser::ParseError => e
+      raise Thor::Error, "Error: failed to parse config: #{e.message}"
+    rescue RulesParser::ParseError => e
+      raise Thor::Error, "Error: failed to parse rules: #{e.message}"
+    end
+
+    def touch_all_mailboxes_in_rules(imap_handler, rules, dry_run: false)
+      rules.each do |rule_set|
+        dst_mailbox = rule_set.destination
+
+        if dry_run
+          warn "creation or existence check of mailbox \"#{dst_mailbox}\" is skipped because this is dry run"
+        else
+          result = imap_handler.touch_mailbox(dst_mailbox)
+          warn "mailbox \"#{dst_mailbox}\" is created" if result
+        end
+      end
+    end
+
+    def filter_mails(imap_handler, rules, mailbox, search_keys = ["ALL"], retry_count = 0, dry_run: false)
+      imap_handler.find_and_handle_mails(mailbox, search_keys) do |message_id|
+        filter_mail(imap_handler, rules, mailbox, message_id, dry_run: dry_run)
+      end
+    rescue IMAPHandler::MailFetchError => e
+      warn "failed to fetch mail (id = #{e.message_id} on mailbox #{e.mailbox}): #{e.bad_response_error_message}"
+
+      # if retry_count is over the threshold, terminate processing
+      unless retry_count < 3
+        warn "retry count is over the threshold, stop processing"
+
+        return
+      end
+
+      warn "wait a moment..."
+
+      # wait a moment...
+      sleep 10
+
+      warn "retry filter all mails on #{e.mailbox}"
+
+      # retry filter all mails itself
+      filter_mails(imap_handler, rules, mailbox, search_keys, retry_count + 1, dry_run: dry_run)
+    end
+
+    def filter_mail(imap_handler, rules, mailbox, message_id, dry_run: false)
+      mail = imap_handler.fetch_header(mailbox, message_id)
+
+      warn "# filtering mail on \"#{mailbox}\" of subject \"#{mail.subject}\"..."
+
+      rules.each do |rule_set|
+        dst_mailbox = rule_set.destination
+        rule = rule_set.rule
+
+        next unless rule.match?(mail)
+
+        warn "the mail matches for the rule of the destination \"#{dst_mailbox}\""
+        warn "moving the mail..."
+
+        if dry_run
+          warn "moving skipped because this is dry run"
+        else
+          result = imap_handler.move(mailbox, message_id, dst_mailbox)
+          if result
+            warn "moving done"
+          else
+            warn "moving skipped because the destination is the same with the current mailbox \"#{mailbox}\""
+          end
+        end
+      end
+
+      imap_handler.close_operation_for_mailbox(mailbox)
+    end
+  end
+end

data/lib/imap_mogura/config_parser/errors.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module ImapMogura
+  module ConfigParser
+    class Error < StandardError; end
+    class ParseError < Error; end
+  end
+end

data/lib/imap_mogura/config_parser.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require "yaml"
+
+require_relative "config_parser/errors"
+
+module ImapMogura
+  module ConfigParser
+    class << self
+      def parse(config_name)
+        config = YAML.safe_load_file(config_name)
+
+        raise ParseError, "config must be in hash format" unless config.is_a?(Hash)
+        raise ParseError, "\"rules:\" must be defined" unless config.key?("rules")
+
+        metadata = config["metadata"]
+        rules = config["rules"]
+
+        [metadata, rules]
+      rescue YAML::SyntaxError => e
+        raise ParseError, "failed to parse yaml: #{e.message}"
+      end
+    end
+  end
+end

data/lib/imap_mogura/imap_handler.rb

@@ -0,0 +1,154 @@
+# frozen_string_literal: true
+
+require "mail"
+require "net/imap"
+
+module ImapMogura
+  class IMAPHandler
+    class Error < StandardError; end
+
+    class MailFetchError < Error
+      def initialize(mailbox, message_id, bad_response_error_message)
+        @mailbox = mailbox
+        @message_id = message_id
+        @bad_response_error_message = bad_response_error_message
+
+        super("failed to fetch mail: id = #{message_id} on \"#{mailbox}\", message = \"#{bad_response_error_message}\"")
+      end
+
+      attr_reader :mailbox, :message_id, :bad_response_error_message
+    end
+
+    def initialize(host, port = 143, starttls: true, usessl: false, certs: nil, verify: true,
+                   auth_info: nil)
+      @imap = Net::IMAP.new(host, port, usessl, certs, verify)
+
+      if usessl || starttls
+        @imap.starttls(certs, verify) if !usessl && starttls
+
+        # in case with TLS, just authenticate with LOGIN command
+        @imap.login(auth_info[:user], auth_info[:password])
+      else
+        # in plain text session, use AUTHENTICATE command
+        @imap.authenticate(auth_info[:auth_type], auth_info[:user], auth_info[:password])
+      end
+
+      initialize_selected_mailbox
+    end
+
+    def close
+      close_mailbox
+      @imap.disconnect
+    end
+
+    def monitor_events(mailbox, events, &block)
+      loop do
+        resp = wait_event_with_idle(mailbox, events)
+
+        break unless block
+
+        block[resp]
+      end
+    end
+
+    def wait_event_with_idle(mailbox, expected_response_names)
+      select_mailbox(mailbox)
+
+      @imap.idle do |resp|
+        if expected_response_names.include? resp.name
+          @imap.idle_done
+
+          return resp
+        end
+      end
+    end
+
+    def all_mailbox_list
+      @imap.list("", "*").map(&:name)
+    end
+
+    def handle_all_mails(mailbox, &block)
+      find_and_handle_mails(mailbox, ["ALL"], &block)
+    end
+
+    def find_and_handle_mails(mailbox, search_keys, &block)
+      select_mailbox(mailbox)
+
+      @imap.search(search_keys).each do |message_id|
+        break unless block
+
+        block[message_id]
+      end
+    end
+
+    def fetch_envelope(mailbox, message_id)
+      with_mailbox_selected(mailbox) do
+        @imap.fetch(message_id, "ENVELOPE")[0].attr["ENVELOPE"]
+      rescue Net::IMAP::BadResponseError => e
+        raise MailFetchError.new(mailbox, message_id, e.message)
+      end
+    end
+
+    def fetch_header(mailbox, message_id)
+      with_mailbox_selected(mailbox) do
+        fetch_data = @imap.fetch(message_id, "BODY.PEEK[HEADER]")[0].attr["BODY[HEADER]"]
+
+        Mail.read_from_string(fetch_data)
+      rescue Net::IMAP::BadResponseError => e
+        raise MailFetchError.new(mailbox, message_id, e.message)
+      end
+    end
+
+    def touch_mailbox(mailbox)
+      @imap.create(mailbox) if @imap.list("", mailbox).empty?
+    end
+
+    def move(src_mailbox, src_message_id, dst_mailbox)
+      return if src_mailbox == dst_mailbox # skip moving if src_mailbox is the same with dst_mailbox
+
+      with_mailbox_selected(src_mailbox, readonly: false) do
+        @imap.copy([src_message_id], dst_mailbox)
+        @imap.store(src_message_id, "+FLAGS", [:Deleted])
+      end
+
+      dst_mailbox
+    end
+
+    def close_operation_for_mailbox(_)
+      close_mailbox
+    end
+
+    private
+
+    def initialize_selected_mailbox
+      @selected_mailbox = nil
+    end
+
+    def with_mailbox_selected(mailbox, readonly: true, &block)
+      select_mailbox(mailbox, readonly: readonly)
+
+      block[]
+    end
+
+    def select_mailbox(mailbox, readonly: true)
+      return if @selected_mailbox == [mailbox, readonly]
+
+      close_mailbox
+
+      if readonly
+        @imap.examine(mailbox)
+      else
+        @imap.select(mailbox)
+      end
+
+      @selected_mailbox = [mailbox, readonly]
+    end
+
+    def close_mailbox
+      return unless @selected_mailbox
+
+      @imap.close
+      @selected_mailbox = nil
+    end
+  end
+end

data/lib/imap_mogura/rules_parser/errors.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module ImapMogura
+  module RulesParser
+    class Error < StandardError; end
+    class ParseError < Error; end
+  end
+end

data/lib/imap_mogura/rules_parser/rule_elements.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module ImapMogura
+  class RuleElement
+    def match?(mail)
+      raise NotImplementedError
+    end
+  end
+
+  class LogicalOperator < RuleElement
+    def initialize(operands)
+      @operands = operands
+
+      super()
+    end
+
+    def to_s
+      "#<#{self.class} operands=#{@operands}>"
+    end
+
+    attr_reader :operands
+  end
+
+  class AndOperator < LogicalOperator
+    def match?(mail)
+      @operands.all? { |elm| elm.match?(mail) }
+    end
+  end
+
+  class OrOperator < LogicalOperator
+    def match?(mail)
+      @operands.any? { |elm| elm.match?(mail) }
+    end
+  end
+
+  class FieldMatcher < RuleElement
+    def initialize(regexp)
+      @regexp = /#{regexp}/ # FIXME: need to care about malicious regular expression injection
+
+      super()
+    end
+
+    attr_reader :regexp
+  end
+
+  class SpecialFieldMatcher < FieldMatcher; end
+
+  class FromMatcher < SpecialFieldMatcher
+    def match?(mail)
+      case mail.from
+      when Enumerable
+        mail.from.any? { |address| address&.match?(@regexp) }
+      else
+        mail.from&.match?(@regexp)
+      end
+    end
+  end
+
+  class SenderMatcher < SpecialFieldMatcher
+    def match?(mail)
+      mail.sender&.match?(@regexp)
+    end
+  end
+
+  class ToMatcher < SpecialFieldMatcher
+    def match?(mail)
+      case mail.to
+      when Enumerable
+        mail.to.any? { |address| address&.match?(@regexp) }
+      else
+        mail.to&.match?(@regexp)
+      end
+    end
+  end
+
+  class CcMatcher < SpecialFieldMatcher
+    def match?(mail)
+      case mail.cc
+      when Enumerable
+        mail.cc.any? { |address| address&.match?(@regexp) }
+      else
+        mail.cc&.match?(@regexp)
+      end
+    end
+  end
+
+  class SubjectMatcher < SpecialFieldMatcher
+    def match?(mail)
+      mail.subject&.match?(@regexp)
+    end
+  end
+
+  class DateMatcher < SpecialFieldMatcher
+    def match?(mail)
+      # TODO: impl
+      raise NotImplementedError
+    end
+  end
+
+  class GeneralFieldMatcher < FieldMatcher
+    def initialize(field_name, regexp)
+      @field_name = field_name
+
+      super(regexp)
+    end
+
+    def match?(mail)
+      mail.headers[@field_name]&.value&.match?(@regexp)
+    end
+  end
+end

data/lib/imap_mogura/rules_parser/rule_set.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module ImapMogura
+  RuleSet = Struct.new(:destination, :raw_rule, :parsed_rule) do
+    HASH_KEYS = %w[destination rule].freeze # rubocop:disable Lint/ConstantDefinitionInBlock
+
+    def initialize(hash)
+      validate_hash(hash)
+
+      super(*HASH_KEYS.map { |k| hash[k] }, nil)
+    end
+
+    alias_method :rule, :parsed_rule
+
+    private
+
+    def validate_hash(hash)
+      HASH_KEYS.each do |k|
+        hash.fetch(k)
+      rescue KeyError => e
+        raise ArgumentError, "given hash doesn't have required key: \"#{e.key}\""
+      end
+
+      return if hash.keys.sort == HASH_KEYS.sort
+
+      raise ArgumentError,
+            "given hash has unknown keys: #{(hash.keys - HASH_KEYS).map { |k| "\"#{k}\"" }.join(", ")}"
+    end
+  end
+end

data/lib/imap_mogura/rules_parser.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require "English"
+require "json"
+
+require_relative "rules_parser/errors"
+require_relative "rules_parser/rule_set"
+require_relative "rules_parser/rule_elements"
+
+module ImapMogura
+  module RulesParser
+    class << self
+      def parse(rules)
+        raise ParseError, "rules is required to be just only one array" unless rules.is_a?(Array)
+
+        rules.map do |item|
+          rule_set = RuleSet.new(item)
+
+          rule_set.parsed_rule = parse_rule(rule_set.raw_rule)
+
+          rule_set
+        rescue ArgumentError
+          raise ParseError,
+                "keywords \"destination\" and \"rule\" are required but some keywords are not specified or unknown keywords are specified. specified keywords: #{item.keys.map do |k|
+                  "\"#{k}\""
+                end.join(", ")}"
+        end
+      end
+
+      private
+
+      def parse_rule(rule)
+        unless rule.is_a?(Hash) && rule.keys.count == 1
+          raise ParseError,
+                "rule should be a hash having only one key, illegal rule: #{JSON.dump(rule)}"
+        end
+
+        k = rule.keys.first
+
+        case k
+        when /^[Aa]nd$/
+          rule_list = rule[k]
+
+          AndOperator.new(parse_rule_list(rule_list))
+        when /^[Oo]r$/
+          rule_list = rule[k]
+
+          OrOperator.new(parse_rule_list(rule_list))
+        when /^(?<special_field_name>[Ff]rom|[Ss]ender|[Tt]o|[Cc]c|[Ss]ubject|[Dd]ate)$/
+          case $LAST_MATCH_INFO[:special_field_name]
+          when /^[Ff]rom$/
+            FromMatcher
+          when /^[Ss]ender$/
+            SenderMatcher
+          when /^[Tt]o$/
+            ToMatcher
+          when /^[Cc]c$/
+            CcMatcher
+          when /^[Ss]ubject$/
+            SubjectMatcher
+          when /^[Dd]ate$/
+            DateMatcher
+          end.new(rule[k])
+        else
+          GeneralFieldMatcher.new(k, rule[k])
+        end
+      end
+
+      def parse_rule_list(rule_list)
+        rule_list.map { |rule| parse_rule(rule) }
+      end
+    end
+  end
+end

data/lib/imap_mogura/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module ImapMogura
+  VERSION = "0.1.1.pre.dev"
+end

data/lib/imap_mogura.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require_relative "imap_mogura/config_parser"
+require_relative "imap_mogura/imap_handler"
+require_relative "imap_mogura/rules_parser"
+require_relative "imap_mogura/cli"
+require_relative "imap_mogura/version"

data/sig/imap_mogura.rbs

@@ -0,0 +1,4 @@
+module ImapMogura
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

metadata

@@ -0,0 +1,119 @@
+--- !ruby/object:Gem::Specification
+name: imap_mogura
+version: !ruby/object:Gem::Version
+  version: 0.1.1.pre.dev
+platform: ruby
+authors:
+- ysk
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2024-11-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: base64
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+- !ruby/object:Gem::Dependency
+  name: mail
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.8'
+- !ruby/object:Gem::Dependency
+  name: net-imap
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.5'
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+description: A mail filtering tool for IMAP.
+email:
+- ysk.univ.1007@gmail.com
+executables:
+- mogura
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec"
+- ".rubocop.yml"
+- LICENSE.txt
+- README.md
+- Rakefile
+- exe/mogura
+- lib/imap_mogura.rb
+- lib/imap_mogura/cli.rb
+- lib/imap_mogura/config_parser.rb
+- lib/imap_mogura/config_parser/errors.rb
+- lib/imap_mogura/imap_handler.rb
+- lib/imap_mogura/rules_parser.rb
+- lib/imap_mogura/rules_parser/errors.rb
+- lib/imap_mogura/rules_parser/rule_elements.rb
+- lib/imap_mogura/rules_parser/rule_set.rb
+- lib/imap_mogura/version.rb
+- sig/imap_mogura.rbs
+homepage: https://github.com/yskuniv/imap_mogura
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/yskuniv/imap_mogura
+  source_code_uri: https://github.com/yskuniv/mogura
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.22
+signing_key: 
+specification_version: 4
+summary: A mail filtering tool for IMAP.
+test_files: []