larch 1.0.0 → 1.0.1

data/lib/larch.rb

@@ -1,123 +1,192 @@
-# Append this file's directory to the include path if it's not there already.
+# Prepend this file's directory to the include path if it's not there already.
 $:.unshift(File.dirname(File.expand_path(__FILE__)))
 $:.uniq!
 
 require 'cgi'
 require 'digest/md5'
 require 'net/imap'
-require 'thread'
 require 'time'
 require 'uri'
 
-require 'larch/util'
 require 'larch/errors'
 require 'larch/imap'
+require 'larch/imap/mailbox'
 require 'larch/logger'
 require 'larch/version'
 
 module Larch
 
   class << self
-    attr_reader :log
+    attr_reader :log, :exclude
 
-    def init(log_level = :info)
+    EXCLUDE_COMMENT = /#.*$/
+    EXCLUDE_REGEX   = /^\s*\/(.*)\/\s*/
+    GLOB_PATTERNS   = {'*' => '.*', '?' => '.'}
+
+    def init(log_level = :info, exclude = [], exclude_file = nil)
       @log = Logger.new(log_level)
 
-      @copied    = 0
-      @failed    = 0
-      @total     = 0
+      @exclude = exclude.map do |e|
+        if e =~ EXCLUDE_REGEX
+          Regexp.new($1, Regexp::IGNORECASE)
+        else
+          glob_to_regex(e.strip)
+        end
+      end
+
+      load_exclude_file(exclude_file) if exclude_file
+
+      # Stats
+      @copied = 0
+      @failed = 0
+      @total  = 0
     end
 
-    # Copies messages from _source_ to _dest_ if they don't already exist in
-    # _dest_. Both _source_ and _dest_ must be instances of Larch::IMAP.
-    def copy(source, dest)
-      raise ArgumentError, "source must be a Larch::IMAP instance" unless source.is_a?(IMAP)
-      raise ArgumentError, "dest must be a Larch::IMAP instance" unless dest.is_a?(IMAP)
+    # Recursively copies all messages in all folders from the source to the
+    # destination.
+    def copy_all(imap_from, imap_to, subscribed_only = false)
+      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)
 
-      msgq  = SizedQueue.new(8)
-      mutex = Mutex.new
+      @copied = 0
+      @failed = 0
+      @total  = 0
 
-      @copied    = 0
-      @failed    = 0
-      @total     = 0
+      imap_from.each_mailbox do |mailbox_from|
+        next if excluded?(mailbox_from.name)
+        next if subscribed_only && !mailbox_from.subscribed?
 
-      @log.info "copying messages from #{source.uri} to #{dest.uri}"
+        mailbox_to = imap_to.mailbox(mailbox_from.name, mailbox_from.delim)
+        mailbox_to.subscribe if mailbox_from.subscribed?
 
-      source_scan = Thread.new do
-        source.scan_mailbox
+        copy_messages(imap_from, mailbox_from, imap_to, mailbox_to)
       end
 
-      dest_scan = Thread.new do
-        dest.scan_mailbox
-      end
+    rescue => e
+      @log.fatal e.message
 
-      source_scan.join
-      dest_scan.join
+    ensure
+      summary
+    end
 
-      source_copy = Thread.new do
-        begin
-          mutex.synchronize { @total = source.length }
-
-          source.each do |id|
-            next if dest.has_message?(id)
-
-            begin
-              msgq << source.peek(id)
-            rescue Larch::IMAP::Error => e
-              # TODO: Keep failed message envelopes in a buffer for later output?
-              mutex.synchronize { @failed += 1 }
-              @log.error e.message
-              next
-            end
-          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, "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)
 
-        rescue => e
-          @log.fatal e.message
+      @copied = 0
+      @failed = 0
+      @total  = 0
 
-        ensure
-          msgq << :finished
-        end
-      end
+      from_name = imap_from.uri_mailbox || 'INBOX'
+      to_name   = imap_to.uri_mailbox || 'INBOX'
 
-      dest_copy = Thread.new do
-        begin
-          while msg = msgq.pop do
-            break if msg == :finished
+      return if excluded?(from_name) || excluded?(to_name)
+
+      copy_messages(imap_from, imap_from.mailbox(from_name), imap_to,
+          imap_to.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
 
-            if msg.envelope.from
-              env_from = msg.envelope.from.first
-              from = "#{env_from.mailbox}@#{env_from.host}"
-            else
-              from = '?'
-            end
+    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 message: #{from} - #{msg.envelope.subject}"
-            dest << msg
+      return if excluded?(mailbox_from.name) || excluded?(mailbox_to.name)
 
-            mutex.synchronize { @copied += 1 }
+      @log.info "copying messages from #{imap_from.host}/#{mailbox_from.name} to #{imap_to.host}/#{mailbox_to.name}"
+
+      imap_from.connect
+      imap_to.connect
+
+      @total += mailbox_from.length
+
+      mailbox_from.each do |id|
+        next if mailbox_to.has_message?(id)
+
+        begin
+          msg = mailbox_from.peek(id)
+
+          if msg.envelope.from
+            env_from = msg.envelope.from.first
+            from = "#{env_from.mailbox}@#{env_from.host}"
+          else
+            from = '?'
           end
 
-        rescue IMAP::FatalError => e
-          @log.fatal e.message
+          @log.info "copying message: #{from} - #{msg.envelope.subject}"
 
-        rescue => e
-          mutex.synchronize { @failed += 1 }
+          mailbox_to << msg
+          @copied += 1
+
+        rescue Larch::IMAP::Error => e
+          # TODO: Keep failed message envelopes in a buffer for later output?
+          @failed += 1
           @log.error e.message
-          retry
+          next
         end
       end
+    end
 
-      dest_copy.join
+    def excluded?(name)
+      name = name.downcase
 
-      source.disconnect
-      dest.disconnect
+      @exclude.each do |e|
+        return true if (e.is_a?(Regexp) ? !!(name =~ e) : File.fnmatch?(e, name))
+      end
 
-      summary
+      return false
     end
 
-    def summary
-      @log.info "#{@copied} message(s) copied, #{@failed} failed, #{@total - @copied - @failed} untouched out of #{@total} total"
+    def glob_to_regex(str)
+      str.gsub!(/(.)/) {|c| GLOB_PATTERNS[$1] || Regexp.escape(c) }
+      Regexp.new("^#{str}$", Regexp::IGNORECASE)
     end
+
+    def load_exclude_file(filename)
+      @exclude ||= []
+      lineno = 0
+
+      File.open(filename, 'rb') do |f|
+        f.each do |line|
+          lineno += 1
+
+          # Strip comments.
+          line.sub!(EXCLUDE_COMMENT, '')
+          line.strip!
+
+          # Skip empty lines.
+          next if line.empty?
+
+          if line =~ EXCLUDE_REGEX
+            @exclude << Regexp.new($1, Regexp::IGNORECASE)
+          else
+            @exclude << glob_to_regex(line)
+          end
+        end
+      end
+
+    rescue => e
+      raise Larch::IMAP::FatalError, "error in exclude file at line #{lineno}: #{e}"
+    end
+
   end
 
-end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: larch
 version: !ruby/object:Gem::Version 
-  version: 1.0.0
+  version: 1.0.1
 platform: ruby
 authors: 
 - Ryan Grove
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-03-16 00:00:00 -07:00
+date: 2009-05-10 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -41,16 +41,20 @@ extensions: []
 extra_rdoc_files: []
 
 files: 
+- HISTORY
 - LICENSE
+- README.rdoc
 - bin/larch
 - lib/larch.rb
 - lib/larch/errors.rb
 - lib/larch/imap.rb
+- lib/larch/imap/mailbox.rb
 - lib/larch/logger.rb
-- lib/larch/util.rb
 - lib/larch/version.rb
 has_rdoc: false
 homepage: http://github.com/rgrove/larch/
+licenses: []
+
 post_install_message: 
 rdoc_options: []
 
@@ -71,9 +75,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.1
+rubygems_version: 1.3.2
 signing_key: 
-specification_version: 2
+specification_version: 3
 summary: Larch syncs messages from one IMAP server to another. Awesomely.
 test_files: []
 

data/lib/larch/util.rb

@@ -1,17 +0,0 @@
-class Module
-
-  # Java-style whole-method synchronization, shamelessly stolen from Sup:
-  # http://sup.rubyforge.org. Assumes the existence of a <tt>@mutex</tt>
-  # variable.
-  def synchronized(*methods)
-    methods.each do |method|
-      class_eval <<-EOF
-        alias unsync_#{method} #{method}
-        def #{method}(*a, &b)
-          @mutex.synchronize { unsync_#{method}(*a, &b) }
-        end
-      EOF
-    end
-  end
-
-end