rgrove-larch 1.0.0.9 → 1.0.0.10

data/HISTORY

@@ -5,7 +5,10 @@ Version 1.0.1 (?)
   * Ruby 1.9.1 support.
   * Much more robust handling of unexpected server disconnects and dropped
     connections.
-  * Option to verify server SSL certificates.
+  * Add --all option to copy all folders recursively.
+  * Add --dry-run option to simulate changes without actually making them.
+  * Add --ssl-certs option to specify a bundle of trusted SSL certificates.
+  * Add --ssl-verify option to verify server SSL certificates.
   * Fix excessive post-scan processing times for very large mailboxes.
   * Fetch message headers in blocks of up to 1024 at a time rather than all at
     once, to prevent potential problems with certain servers when a mailbox

data/bin/larch

@@ -23,6 +23,7 @@ EOS
     opt :to,   "URI of the destination IMAP server.", :short => '-t', :type => :string, :required => true
 
     text "\nCopy Options:"
+    opt :all,              "Copy all folders recursively", :short => :none
     opt :from_folder,      "Source folder to copy from", :short => :none, :default => 'INBOX'
     opt :from_pass,        "Source server password (default: prompt)", :short => :none, :type => :string
     opt :from_user,        "Source server username (default: prompt)", :short => :none, :type => :string
@@ -31,7 +32,7 @@ EOS
     opt :to_user,          "Destination server username (default: prompt)", :short => :none, :type => :string
 
     text "\nGeneral Options:"
-    # opt :dry_run,          "Don't actually do anything.", :short => '-n'
+    opt :dry_run,          "Don't actually make any changes.", :short => '-n'
     opt :fast_scan,        "Use a faster (but less accurate) method to scan mailboxes. This may result in messages being re-copied.", :short => :none
     opt :max_retries,      "Maximum number of times to retry after a recoverable error", :short => :none, :default => 3
     opt :no_create_folder, "Don't create destination folders that don't already exist", :short => :none
@@ -47,6 +48,10 @@ EOS
     end
   end
 
+  if options[:all_given] && (options[:from_folder_given] || options[:to_folder_given])
+    Trollop.die :all, "may not be used with --from-folder or --to-folder"
+  end
+
   unless Logger::LEVELS.has_key?(options[:verbosity].to_sym)
     Trollop.die :verbosity, "must be one of: #{Logger::LEVELS.keys.join(', ')}"
   end
@@ -55,6 +60,13 @@ EOS
   uri_from = URI(options[:from])
   uri_to   = URI(options[:to])
 
+  # --all option overrides folders specified in URIs
+  if options[:all_given]
+    uri_from.path = ''
+    uri_to.path   = ''
+  end
+
+  # --from-folder and --to-folder options override folders specified in URIs
   if options[:from_folder_given] || options[:to_folder_given]
     uri_from.path = '/' + CGI.escape(options[:from_folder].gsub(/^\//, ''))
     uri_to.path   = '/' + CGI.escape(options[:to_folder].gsub(/^\//, ''))
@@ -78,6 +90,7 @@ EOS
   Net::IMAP.debug = true if @log.level == :insane
 
   imap_from = Larch::IMAP.new(uri_from,
+      :dry_run     => options[:dry_run],
       :fast_scan   => options[:fast_scan],
       :max_retries => options[:max_retries],
       :ssl_certs   => options[:ssl_certs] || nil,
@@ -85,7 +98,8 @@ EOS
   )
 
   imap_to = Larch::IMAP.new(uri_to,
-      :create_mailbox => !options[:no_create_folder],
+      :create_mailbox => !options[:no_create_folder] && !options[:dry_run],
+      :dry_run        => options[:dry_run],
       :fast_scan      => options[:fast_scan],
       :max_retries    => options[:max_retries],
       :ssl_certs      => options[:ssl_certs] || nil,
@@ -101,5 +115,9 @@ EOS
     end
   end
 
-  copy_folder(imap_from, imap_to)
+  if options[:all_given]
+    copy_all(imap_from, imap_to)
+  else
+    copy_folder(imap_from, imap_to)
+  end
 end

data/lib/larch/imap/mailbox.rb

@@ -13,13 +13,14 @@ class Mailbox
   # Minimum time (in seconds) allowed between mailbox scans.
   SCAN_INTERVAL = 60
 
-  def initialize(imap, name, delim, *attr)
+  def initialize(imap, name, delim, subscribed, *attr)
     raise ArgumentError, "must provide a Larch::IMAP instance" unless imap.is_a?(Larch::IMAP)
 
-    @delim = delim
-    @imap  = imap
-    @name  = name
-    @attr  = attr
+    @imap       = imap
+    @name       = name
+    @delim      = delim
+    @subscribed = subscribed
+    @attr       = attr
 
     @ids       = {}
     @last_id   = 0
@@ -54,7 +55,7 @@ class Mailbox
       imap_select(!!@imap.options[:create_mailbox])
 
       debug "appending message: #{message.id}"
-      @imap.conn.append(@name, message.rfc822, message.flags, message.internaldate)
+      @imap.conn.append(@name, message.rfc822, message.flags, message.internaldate) unless @imap.options[:dry_run]
     end
 
     true
@@ -161,6 +162,25 @@ class Mailbox
     end
   end
 
+  # Subscribes to this mailbox.
+  def subscribe(force = false)
+    return if subscribed? && !force
+    @imap.safely { @imap.conn.subscribe(@name) }
+    @mutex.synchronize { @subscribed = true }
+  end
+
+  # Returns +true+ if this mailbox is subscribed, +false+ otherwise.
+  def subscribed?
+    @subscribed
+  end
+
+  # Unsubscribes to this mailbox.
+  def unsubscribe(force = false)
+    return unless subscribed? || force
+    @imap.safely { @imap.conn.unsubscribe(@name) }
+    @mutex.synchronize { @subscribed = false }
+  end
+
   private
 
   # Creates an id suitable for uniquely identifying a specific message across
@@ -240,10 +260,10 @@ class Mailbox
       rescue Net::IMAP::NoResponseError => e
         raise Error, "unable to select mailbox: #{e.message}" unless create
 
-        info "creating mailbox: #{mailbox}"
+        info "creating mailbox: #{@name}"
 
         begin
-          @imap.conn.create(@name)
+          @imap.conn.create(@name) unless @imap.options[:dry_run]
           retry
         rescue => e
           raise Error, "unable to create mailbox: #{e.message}"

data/lib/larch/imap.rb

@@ -24,6 +24,12 @@ class IMAP
   #   If +true+, mailboxes that don't already exist will be created if
   #   necessary.
   #
+  # [:dry_run]
+  #   If +true+, read-only operations will be performed as usual and all change
+  #   operations will be simulated, but no changes will actually be made. Note
+  #   that it's not actually possible to simulation mailbox creation, so
+  #   +:dry_run+ mode always behaves as if +:create_mailbox+ is +false+.
+  #
   # [:fast_scan]
   #   If +true+, a faster but less accurate method will be used to scan
   #   mailboxes. This will speed up the initial mailbox scan, but will also
@@ -125,7 +131,7 @@ class IMAP
       raise unless @options[:create_mailbox] && retries == 0
 
       info "creating mailbox: #{name}"
-      safely { @conn.create(name) }
+      safely { @conn.create(name) } unless @options[:dry_run]
 
       retries += 1
       retry
@@ -306,15 +312,17 @@ class IMAP
   end
 
   def update_mailboxes
-    list = safely { @conn.list('', '*') }
+    all        = safely { @conn.list('', '*') }
+    subscribed = safely { @conn.lsub('', '*') }
 
     @mutex.synchronize do
       # Remove cached mailboxes that no longer exist.
-      @mailboxes.delete_if {|k, v| !list.any?{|mb| mb.name == k}}
+      @mailboxes.delete_if {|k, v| !all.any?{|mb| mb.name == k}}
 
       # Update cached mailboxes.
-      list.each do |mb|
-        @mailboxes[mb.name] ||= Mailbox.new(self, mb.name, mb.delim, mb.attr)
+      all.each do |mb|
+        @mailboxes[mb.name] ||= Mailbox.new(self, mb.name, mb.delim,
+            subscribed.any?{|s| s.name == mb.name}, mb.attr)
       end
     end
   end

data/lib/larch/version.rb

@@ -1,6 +1,6 @@
 module Larch
   APP_NAME      = 'Larch'
-  APP_VERSION   = '1.0.0.7'
+  APP_VERSION   = '1.0.0.10'
   APP_AUTHOR    = 'Ryan Grove'
   APP_EMAIL     = 'ryan@wonko.com'
   APP_URL       = 'http://github.com/rgrove/larch/'

data/lib/larch.rb

@@ -28,26 +28,70 @@ module Larch
       @total  = 0
     end
 
+    # Recursively copies all messages in all folders from the source to the
+    # destination.
+    def copy_all(imap_from, imap_to)
+      raise ArgumentError, "imap_from must be a Larch::IMAP instance" unless imap_from.is_a?(IMAP)
+      raise ArgumentError, "imap_to must be a Larch::IMAP instance" unless imap_to.is_a?(IMAP)
+
+      imap_from.each_mailbox do |mailbox_from|
+        @copied = 0
+        @failed = 0
+        @total  = 0
+
+        mailbox_to = imap_to.mailbox(mailbox_from.name)
+        copy_messages(imap_from, mailbox_from, imap_to, mailbox_to)
+        mailbox_to.subscribe if mailbox_from.subscribed?
+
+        summary
+      end
+
+    rescue => e
+      @log.fatal e.message
+      summary
+    end
+
+    # Copies the messages in a single IMAP folder (non-recursively) from the
+    # source to the destination.
     def copy_folder(imap_from, imap_to)
-      raise ArgumentError, "source must be a Larch::IMAP instance" unless imap_from.is_a?(IMAP)
-      raise ArgumentError, "dest must be a Larch::IMAP instance" unless imap_to.is_a?(IMAP)
+      raise ArgumentError, "imap_from must be a Larch::IMAP instance" unless imap_from.is_a?(IMAP)
+      raise ArgumentError, "imap_to must be a Larch::IMAP instance" unless imap_to.is_a?(IMAP)
 
       @copied = 0
       @failed = 0
       @total  = 0
 
-      mailbox_from_name = imap_from.uri_mailbox || 'INBOX'
-      mailbox_to_name   = imap_to.uri_mailbox || 'INBOX'
+      copy_messages(imap_from, imap_from.mailbox(imap_from.uri_mailbox || 'INBOX'),
+          imap_to, imap_to.mailbox(imap_to.uri_mailbox || 'INBOX'))
 
-      @log.info "copying messages from #{imap_from.host}/#{mailbox_from_name} to #{imap_to.host}/#{mailbox_to_name}"
+      imap_from.disconnect
+      imap_to.disconnect
+
+    rescue => e
+      @log.fatal e.message
+
+    ensure
+      summary
+    end
+
+    def summary
+      @log.info "#{@copied} message(s) copied, #{@failed} failed, #{@total - @copied - @failed} untouched out of #{@total} total"
+    end
+
+    private
+
+    def copy_messages(imap_from, mailbox_from, imap_to, mailbox_to)
+      raise ArgumentError, "imap_from must be a Larch::IMAP instance" unless imap_from.is_a?(IMAP)
+      raise ArgumentError, "mailbox_from must be a Larch::IMAP::Mailbox instance" unless mailbox_from.is_a?(IMAP::Mailbox)
+      raise ArgumentError, "imap_to must be a Larch::IMAP instance" unless imap_to.is_a?(IMAP)
+      raise ArgumentError, "mailbox_to must be a Larch::IMAP::Mailbox instance" unless mailbox_to.is_a?(IMAP::Mailbox)
+
+      @log.info "copying messages from #{imap_from.host}/#{mailbox_from.name} to #{imap_to.host}/#{mailbox_to.name}"
 
       imap_from.connect
       imap_to.connect
 
-      mailbox_from = imap_from.mailbox(mailbox_from_name)
-      mailbox_to   = imap_to.mailbox(mailbox_to_name)
-
-      @total = mailbox_from.length
+      @total += mailbox_from.length
 
       mailbox_from.each do |id|
         next if mailbox_to.has_message?(id)
@@ -74,19 +118,6 @@ module Larch
           next
         end
       end
-
-      imap_from.disconnect
-      imap_to.disconnect
-
-    rescue => e
-      @log.fatal e.message
-
-    ensure
-      summary
-    end
-
-    def summary
-      @log.info "#{@copied} message(s) copied, #{@failed} failed, #{@total - @copied - @failed} untouched out of #{@total} total"
     end
   end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: rgrove-larch
 version: !ruby/object:Gem::Version 
-  version: 1.0.0.9
+  version: 1.0.0.10
 platform: ruby
 authors: 
 - Ryan Grove