pec_ruby 0.2.2 → 0.2.3

data/lib/pec_ruby/client.rb

@@ -5,7 +5,7 @@ require 'mail'
 
 module PecRuby
   class Client
-    attr_reader :imap, :host, :username
+    attr_reader :imap, :host, :username, :current_folder
 
     def initialize(host:, username:, password:, ssl: true)
       @host = host
@@ -13,6 +13,7 @@ module PecRuby
       @password = password
       @ssl = ssl
       @imap = nil
+      @current_folder = nil
     end
 
     def connect
@@ -29,48 +30,105 @@ module PecRuby
 
       begin
         @imap.logout if @imap && !@imap.disconnected?
-      rescue => e
+      rescue StandardError => e
         # Ignore logout errors if connection is already closed
       end
-      
+
       begin
         @imap.disconnect if @imap && !@imap.disconnected?
-      rescue => e
+      rescue StandardError => e
         # Ignore disconnect errors if connection is already closed
       end
-      
+
       @imap = nil
     end
 
     def connected?
       return false unless @imap
+
       !@imap.disconnected?
     end
 
+    # Get the list of available folders in the mailbox
+    def available_folders
+      raise ConnectionError, 'Not connected' unless connected?
+
+      @imap.list('', '*').map(&:name)
+    end
+
+    def select_folder(folder)
+      raise ConnectionError, 'Not connected' unless connected?
+
+      # Check if the folder exists
+      raise FolderError, "Folder '#{folder}' does not exist" unless available_folders.include?(folder)
+
+      @imap.select(folder)
+      @current_folder = folder
+    rescue Net::IMAP::Error => e
+      raise FolderError, "Failed to select folder '#{folder}': #{e.message}"
+    end
+
+    def select_inbox
+      select_folder('INBOX')
+      @current_folder = 'INBOX'
+    rescue FolderError => e
+      raise FolderError, "Failed to select INBOX: #{e.message}"
+    end
+
     # Get all messages or a subset
     def messages(limit: nil, reverse: true)
-      raise ConnectionError, "Not connected" unless connected?
+      raise ConnectionError, 'Not connected' unless connected?
+
+      # Use search to get available sequence numbers (safer approach)
+      begin
+        sequence_numbers = @imap.search(['ALL'])
+      rescue Net::IMAP::Error => e
+        raise ConnectionError, "Failed to search messages: #{e.message}"
+      end
       
-      sequence_numbers = @imap.search(['ALL'])
-      sequence_numbers = sequence_numbers.reverse if reverse
-      sequence_numbers = sequence_numbers.first(limit) if limit
+      return [] if sequence_numbers.empty?
+
+      # Sort and limit the sequence numbers
+      if reverse
+        sequence_numbers = sequence_numbers.sort.reverse
+      else
+        sequence_numbers = sequence_numbers.sort
+      end
       
-      fetch_messages(sequence_numbers)
+      # Apply limit if specified
+      sequence_numbers = sequence_numbers.first(limit) if limit
+
+      fetch_messages_by_sequence(sequence_numbers)
     end
 
     # Get a specific message by UID
     def message(uid)
-      raise ConnectionError, "Not connected" unless connected?
-      
-      fetch_data = @imap.uid_fetch(uid, ["UID", "ENVELOPE", "BODYSTRUCTURE"])
+      raise ConnectionError, 'Not connected' unless connected?
+
+      fetch_data = @imap.uid_fetch(uid, %w[UID ENVELOPE BODYSTRUCTURE])
       return nil if fetch_data.nil? || fetch_data.empty?
-      
+
       Message.new(self, fetch_data.first)
     end
 
-    # Get messages with postacert.eml only
-    def pec_messages(limit: nil, reverse: true)
-      messages(limit: limit, reverse: reverse).select(&:has_postacert?)
+
+    # Internal method to fetch messages by sequence number
+    def fetch_messages_by_sequence(sequence_numbers)
+      return [] if sequence_numbers.empty?
+
+      # Fetch messages in batches to avoid memory issues
+      batch_size = 50
+      all_messages = []
+
+      sequence_numbers.each_slice(batch_size) do |seq_batch|
+        fetch_data = @imap.fetch(seq_batch, %w[UID ENVELOPE BODYSTRUCTURE])
+        next if fetch_data.nil?
+
+        batch_messages = fetch_data.map { |data| Message.new(self, data) }
+        all_messages.concat(batch_messages)
+      end
+
+      all_messages
     end
 
     # Internal method to fetch message body parts
@@ -81,20 +139,10 @@ module PecRuby
     private
 
     def authenticate
-      @imap.authenticate("PLAIN", @username, @password)
+      @imap.authenticate('PLAIN', @username, @password)
     rescue Net::IMAP::Error => e
       raise AuthenticationError, "Authentication failed: #{e.message}"
     end
 
-    def select_inbox
-      @imap.select('INBOX')
-    end
-
-    def fetch_messages(sequence_numbers)
-      return [] if sequence_numbers.empty?
-      
-      messages_data = @imap.fetch(sequence_numbers, ["UID", "ENVELOPE", "BODYSTRUCTURE"])
-      messages_data.map { |msg_data| Message.new(self, msg_data) }
-    end
   end
-end
+end

data/lib/pec_ruby/message.rb

@@ -15,8 +15,41 @@ module PecRuby
       @postacert_extracted = false
     end
 
-    # Basic envelope information
+    # Basic envelope information - now points to postacert.eml when available
     def subject
+      if has_postacert?
+        postacert_message&.subject
+      else
+        original_subject
+      end
+    end
+
+    def from
+      if has_postacert?
+        postacert_message&.from&.first
+      else
+        original_from
+      end
+    end
+
+    def to
+      if has_postacert?
+        postacert_message&.to || []
+      else
+        original_to
+      end
+    end
+
+    def date
+      if has_postacert?
+        postacert_message&.date
+      else
+        original_date
+      end
+    end
+
+    # Original message envelope information (the outer PEC container)
+    def original_subject
       return nil unless @envelope.subject
       
       decoded = Mail::Encodings.value_decode(@envelope.subject)
@@ -24,20 +57,20 @@ module PecRuby
       decoded.strip
     end
 
-    def from
+    def original_from
       return nil unless @envelope.from&.first
       
       from_addr = @envelope.from.first
       extract_real_sender(from_addr)
     end
 
-    def to
+    def original_to
       return [] unless @envelope.to
       
       @envelope.to.map { |addr| "#{addr.mailbox}@#{addr.host}" }
     end
 
-    def date
+    def original_date
       @envelope.date ? Time.parse(@envelope.date.to_s) : nil
     end
 
@@ -69,28 +102,8 @@ module PecRuby
       @postacert_mail
     end
 
-    # Get original message subject
-    def original_subject
-      postacert_message&.subject
-    end
-
-    # Get original message sender
-    def original_from
-      postacert_message&.from&.first
-    end
-
-    # Get original message recipients
-    def original_to
-      postacert_message&.to || []
-    end
-
-    # Get original message date
-    def original_date
-      postacert_message&.date
-    end
-
-    # Get original message body with format information
-    def original_body
+    # Get postacert message body with format information
+    def postacert_body
       mail = postacert_message
       return nil unless mail
 
@@ -116,8 +129,8 @@ module PecRuby
       }
     end
 
-    # Get original message body as plain text only
-    def original_body_text
+    # Get postacert message body as plain text only
+    def postacert_body_text
       mail = postacert_message
       return nil unless mail
 
@@ -132,8 +145,8 @@ module PecRuby
       raw_body.dup.force_encoding(charset).encode("UTF-8")
     end
 
-    # Get original message body as HTML only
-    def original_body_html
+    # Get postacert message body as HTML only
+    def postacert_body_html
       mail = postacert_message
       return nil unless mail
 
@@ -148,13 +161,40 @@ module PecRuby
       raw_body.dup.force_encoding(charset).encode("UTF-8")
     end
 
-    # Get original message attachments (with memoization)
-    def original_attachments
-      @original_attachments ||= begin
+    # Get message body - preferring postacert.eml if available, otherwise direct message
+    def raw_body
+      if has_postacert?
+        postacert_body
+      else
+        direct_message_body
+      end
+    end
+
+    # Get message body as plain text - preferring postacert.eml if available, otherwise direct message
+    def raw_body_text
+      if has_postacert?
+        postacert_body_text
+      else
+        direct_message_body_text
+      end
+    end
+
+    # Get message body as HTML - preferring postacert.eml if available, otherwise direct message
+    def raw_body_html
+      if has_postacert?
+        postacert_body_html
+      else
+        direct_message_body_html
+      end
+    end
+
+    # Get postacert message attachments (with memoization)
+    def postacert_attachments
+      @postacert_attachments ||= begin
         mail = postacert_message
         attachments = []
         
-        # Add attachments from the original message
+        # Add attachments from the postacert message
         if mail&.attachments
           attachments += mail.attachments.map { |att| Attachment.new(att) }
         end
@@ -167,14 +207,53 @@ module PecRuby
       end
     end
 
-    # Get original message attachments that are NOT postacert.eml files
+    # Get postacert message attachments that are NOT postacert.eml files
+    def postacert_regular_attachments
+      postacert_attachments.reject(&:postacert?)
+    end
+
+    # Get attachments - preferring postacert.eml if available, otherwise direct message
+    def attachments
+      if has_postacert?
+        postacert_attachments
+      else
+        [] # Direct messages typically don't have attachments via IMAP
+      end
+    end
+
+    # Get regular attachments (non-postacert.eml)
+    def regular_attachments
+      if has_postacert?
+        postacert_regular_attachments
+      else
+        [] # Direct messages typically don't have attachments via IMAP
+      end
+    end
+
+    # Legacy methods for backward compatibility
+    def original_attachments
+      postacert_attachments
+    end
+
     def original_regular_attachments
-      original_attachments.reject(&:postacert?)
+      postacert_regular_attachments
     end
 
-    # Get nested postacert.eml files from original message attachments
+    def original_body
+      postacert_body
+    end
+
+    def original_body_text
+      postacert_body_text
+    end
+
+    def original_body_html
+      postacert_body_html
+    end
+
+    # Get nested postacert.eml files from postacert message attachments
     def nested_postacerts
-      @nested_postacerts ||= original_attachments.select(&:postacert?)
+      @nested_postacerts ||= postacert_attachments.select(&:postacert?)
     end
 
     # Check if original message has nested postacert.eml files
@@ -329,5 +408,76 @@ module PecRuby
     def extract_text_part(mail, preferred_type = "text/plain")
       NestedPostacertMessage.new(mail).send(:extract_text_part, mail, preferred_type)
     end
+
+    private
+
+    # Get the direct message body (without postacert.eml)
+    def direct_message_body
+      mail = direct_message_mail
+      return nil unless mail
+
+      text_part = extract_text_part(mail, "text/plain")
+      html_part = extract_text_part(mail, "text/html")
+      
+      # Prefer text/plain, but return HTML if that's all we have
+      selected_part = text_part || html_part
+
+      return nil unless selected_part
+
+      raw_body = selected_part.body.decoded
+      charset = selected_part.charset || 
+                selected_part.content_type_parameters&.[]("charset") || 
+                "UTF-8"
+      
+      content = raw_body.dup.force_encoding(charset).encode("UTF-8")
+      
+      {
+        content: content,
+        content_type: selected_part.mime_type,
+        charset: charset
+      }
+    end
+
+    # Get the direct message body as plain text
+    def direct_message_body_text
+      mail = direct_message_mail
+      return nil unless mail
+
+      text_part = extract_text_part(mail, "text/plain")
+      return nil unless text_part
+
+      raw_body = text_part.body.decoded
+      charset = text_part.charset || 
+                text_part.content_type_parameters&.[]("charset") || 
+                "UTF-8"
+      
+      raw_body.dup.force_encoding(charset).encode("UTF-8")
+    end
+
+    # Get the direct message body as HTML
+    def direct_message_body_html
+      mail = direct_message_mail
+      return nil unless mail
+
+      html_part = extract_text_part(mail, "text/html")
+      return nil unless html_part
+
+      raw_body = html_part.body.decoded
+      charset = html_part.charset || 
+                html_part.content_type_parameters&.[]("charset") || 
+                "UTF-8"
+      
+      raw_body.dup.force_encoding(charset).encode("UTF-8")
+    end
+
+    # Get the direct message parsed as Mail object
+    def direct_message_mail
+      @direct_message_mail ||= begin
+        raw_data = @client.fetch_body_part(@uid, "")
+        Mail.read_from_string(raw_data)
+      rescue => e
+        raise Error, "Failed to extract direct message: #{e.message}"
+      end
+    end
   end
 end

data/lib/pec_ruby/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module PecRuby
-  VERSION = "0.2.2"
-end
+  VERSION = '0.2.3'
+end

data/lib/pec_ruby.rb

@@ -1,13 +1,13 @@
 # frozen_string_literal: true
 
-require_relative "pec_ruby/version"
-require_relative "pec_ruby/client"
-require_relative "pec_ruby/message"
-require_relative "pec_ruby/attachment"
+require_relative 'pec_ruby/version'
+require_relative 'pec_ruby/client'
+require_relative 'pec_ruby/message'
+require_relative 'pec_ruby/attachment'
 
 # CLI is optional - only load if dependencies are available
 begin
-  require_relative "pec_ruby/cli"
+  require_relative 'pec_ruby/cli'
 rescue LoadError
   # CLI dependencies not available - skip CLI functionality
 end
@@ -18,4 +18,5 @@ module PecRuby
   class AuthenticationError < Error; end
   class MessageNotFoundError < Error; end
   class PostacertNotFoundError < Error; end
-end
+  class FolderError < Error; end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pec_ruby
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.2.3
 platform: ruby
 authors:
 - EMG
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-07-13 00:00:00.000000000 Z
+date: 2025-07-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: mail
@@ -38,6 +38,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.3'
+- !ruby/object:Gem::Dependency
+  name: tty-screen
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement