swallow 0.0.1

data/README

@@ -0,0 +1,2 @@
+Just gem install this package. Be sure to set your GEM_HOME and GEM_PATH.
+

data/bin/swallow

@@ -0,0 +1,7 @@
+#!/usr/bin/ruby -w
+
+require "swallow"
+
+admin = Swallow::Admin.new
+admin.process_junk
+admin.process_inbox

data/lib/email.rb

@@ -0,0 +1,54 @@
+#!/usr/bin/ruby
+
+require 'time_extentions'
+
+module Swallow
+    class Email
+        attr_accessor :id, :weird_id, :host, :order
+        attr_accessor :filename
+
+        def initialize(filename)
+            @filename = filename
+            path_parts = filename.split(/\//)
+            parse_filename(path_parts[-1])
+        end
+
+        def parse_filename(file)
+            uppername, @order, @read = file.split(/,/)
+            @id, @weird_id, @host = uppername.split(/\./)
+        end
+
+        def newer_than?(limit)
+            File.open(@filename).newer_than?(Date.today - limit)
+        end
+        
+        def older_than?(limit)
+            File.open(@filename).older_than?(Date.today - limit)
+        end
+        
+        def read?
+            @read == "S"
+        end
+
+        def mark_read
+            # modify filename to "S" on end
+        end
+
+        def to_s
+            File.open(@filename).read
+        end
+        def delete
+            File.delete(@filename)
+        end
+    end
+end
+
+if $0 == __FILE__ then
+    include Swallow
+    e = Email.new(ARGV[0])
+    puts e
+    puts "The email is unread" if e.read? == false
+    puts "Email ID: #{e.id}"
+    puts "The email is newer than one day" if e.newer_than?(1)
+    puts "The email is older than one day" if e.older_than?(1)
+end

data/lib/maildir.rb

@@ -0,0 +1,109 @@
+#!/usr/bin/ruby -w
+
+require 'email'
+require 'time_extentions'
+
+module Swallow
+    class MailDirFolder
+        def initialize(folder_path)
+            @folder_path = folder_path
+            @sub_folders = ["cur", "new", "tmp"]
+        end
+
+        def enum
+            Dir.chdir(@folder_path)
+            #puts "Subfolders:"
+            a = Array.new
+            Dir.glob("\.*").sort.each { |dir|
+                next unless File.directory?(dir)
+                next if dir == "." or dir == ".."
+                #puts "#{dir}"
+                a << dir
+            }
+            a
+        end
+
+        def path
+            @folder_path
+        end
+
+        def count
+            v = 0
+            @sub_folders.each { |dir|
+                v += length(dir)
+            }
+            return v
+        end
+
+        def unread_count
+            length("new")
+        end
+
+        def read_count
+            length("cur")
+        end
+
+        def unknown_count
+            length("tmp")
+        end
+
+        def length(sub_path)
+            length = 0
+            Dir.open(File.join(@folder_path,sub_path)).each { |filename|
+                next if filename == "." or filename == ".."
+                length += 1
+            }
+            length
+        end
+
+        def emails
+            list = Array.new
+            @sub_folders.each { |sub_path|
+                path = File.join(@folder_path, sub_path)
+                Dir.open(path).each { |f|
+                    filename = File.join(path,f)
+                    next if File.directory?(filename)
+                    list << Email.new(filename)
+                }
+            }
+            return list
+        end
+
+        def delete_all_emails
+            count = emails.length
+            emails.each {|email| email.delete }
+            puts "Deleted #{count} emails"
+        end
+
+        def emails_newer_than(limit)
+            emails.find_all { |e| e.newer_than?(limit) }
+        end
+
+        def emails_older_than(limit)
+            emails.find_all { |e| e.older_than?(limit) }
+        end
+
+        def sweep!(limit)
+          if limit.kind_of? Integer then
+            @sub_folder.each { |sub_path|
+              Dir.open(File.join(@folder_path,sub_path)).sweep!(limit)
+            }
+          end
+        end
+        def to_s
+            "#{@folder_path} has #{unread_count} unread messages and #{read_count} read messages (#{unknown_count})."
+        end
+    end
+end
+
+if $0 == __FILE__ then
+    include Swallow
+    root = "/home/#{ENV['USER']}/Maildir/"
+    m = MailDirFolder.new(root)
+    puts m.to_s
+    m.enum.each { |folder|
+    n = MailDirFolder.new(m.path+folder)
+        puts n.to_s
+    puts n.enum
+    }
+end

data/lib/ruleset.rb

@@ -0,0 +1,50 @@
+#!/usr/bin/ruby
+
+require 'yaml'
+
+module Swallow
+    class RuleSet
+      attr_reader :rules
+
+      def initialize(filename)
+        @rules = YAML.load_file(filename)
+        @rules.each do |rule|
+          if rule[:folder] != nil then
+            if rule[:domains] != nil then
+              # replace the string domain list with a regexp domain list
+              rule[:domains] = rule[:domains].map { |i| Regexp.quote(i) }
+            end
+            if rule[:to] != nil then
+              # replace the string to list with a regexp to list
+              rule[:to] = rule[:to].map { |i| Regexp.quote(i) }
+            end
+            if rule[:from] != nil then
+              # replace the string from list with a regexp from list
+              rule[:from] = rule[:from].map { |i| Regexp.quote(i) }
+            end
+          end
+        end
+      end  
+      def to_s
+        s = String.new("Rules Hash Holds:\n")
+        @rules.each { |rule|
+          s << "#{rule[:folder]}"
+          s << "#{rule[:to]}" if rule[:to] != nil
+          s << "#{rule[:from]}" if rule[:from] != nil
+          s <<  "#{rule[:domains]}" if rules[:domains] != nil
+        }
+        s
+      end
+    end
+end
+
+# Self Test
+if $0 == __FILE__
+  r = RuleSet.new(ARGV[0])
+  r.getRuleset.each { |rules|
+    puts "Folder: #{rules[:folder]}"
+    rules[:domains].each { |domain|
+      puts "Domain: #{domain}"
+    } unless rules[:domains] == nil
+  }
+end

data/lib/spamdetector.rb

@@ -0,0 +1,130 @@
+#!/usr/bin/ruby -w
+require 'maildir'
+
+def pipe(program, text)
+    IO.popen(program,"w") do |f|
+        f.print(text)
+    end
+    return $?>>8
+end
+
+def process(program, text)
+    IO.popen(program, "wr") do |f|
+        f.print(text)
+        return f.read
+    end
+end
+
+module Swallow
+    class SpamDetector
+        def initialize
+            @innocent_cmd = "cat"
+            @training_cmd = "cat"
+        end
+
+        def process_folder(cmd, folder, should_delete = false)
+            count = 0
+            if folder.kind_of? MailDirFolder
+                count = folder.emails.length
+                folder.emails.each { |email|
+                    pipe(cmd, email.to_s)
+                    email.delete if should_delete == true
+                }
+            end
+            if folder.kind_of? String
+                Dir.open(folder).each { |f|
+                    next if File.directory?(f)
+                    File.open(File.join(folder,f)) do |out|
+                        pipe(cmd, out.read)
+                    end
+                    count += 1
+                    File.delete(File.join(folder,f)) if should_delete == true
+                }
+            end
+            puts "Processed #{count} messages in #{folder}"
+        end
+
+        def generate_cmd(params)
+            if params.kind_of? Hash
+                return "echo"
+            end
+        end
+
+        def train_and_clean_folder(folder)
+            process_folder(generate_cmd(:source => "corpus", :class => "spam"), folder, true)
+        end
+
+        def train_and_retain_folder(folder)
+            process_folder(generate_cmd(:source => "corpus", :class => "innocent"), folder)
+        end
+
+        def is_spam?(message_text)
+        end
+
+        def is_innocent?(message_text)
+        end
+
+        # this function takes an array of email objects and trains them as innocent
+        def train_emails_as_innocent(emails)
+            if emails != nil then
+                if emails.kind_of? Array then
+                    emails.each { |email|
+                        if email.kind_of? Email then
+                            pipe(generate_cmd(:source => "corpus", :class => "innocent"), email.to_s)
+                        end
+                    }
+                    puts "Trained #{emails.length} emails as innocent"
+                end
+            end
+        end
+
+        # this function takes an array of email objects and trains them as spam
+        def train_emails_as_spam(emails)
+            if emails != nil then
+                if emails.kind_of? Array then
+                    emails.each { |email|
+                        if email.kind_of? Email then
+                            pipe(generate_cmd(:source => "corpus", :class => "spam"), email.to_s)
+                        end
+                    }
+                    puts "Trained #{emails.length} emails as spam"
+                end
+            end
+        end
+    end
+
+    class DSpamEngine < SpamDetector
+        def initialize(add_params = nil)
+            @base_cmd="dspam"
+            if add_params == nil then
+                @cmd_params = Hash.new
+            else
+                @cmd_params = add_params
+            end
+            if @cmd_params[:mode] == nil
+                @cmd_params[:mode] = "teft"
+            end
+            if @cmd_params[:path] != nil
+                @base_cmd=@cmd_params[:path]
+            end
+            if pipe(@base_cmd + " --version", "") == 127
+                throw IOError
+            end
+        end
+
+        def generate_cmd(params)
+            if params.kind_of? Hash
+                return "#{@base_cmd} --mode=#{@cmd_params[:mode]} --source=#{params[:source]} --class=#{params[:class]} --feature=noise --user=#{ENV['USER']}"
+            else
+                return "#{@base_cmd} --mode=#{@cmd_params[:mode]}"
+            end
+        end
+    end
+end
+
+if $0 == __FILE__ then
+    include Swallow
+    exit(1) unless ARGV.length > 0
+    d = DSpamEngine.new()
+    d.train_and_clean_folder(ARGV[0])
+end

data/lib/swallow.rb

@@ -0,0 +1,44 @@
+#!/usr/bin/ruby -w
+
+require 'maildir'
+require 'spamdetector'
+require 'ruleset'
+require 'yaml'
+
+module Swallow
+    class Admin
+        def initialize(config_file = nil)
+            if config_file != nil then
+                @config_path = config_file
+            else
+                @config_path = "#{ENV['HOME']}/.swallow-config"
+            end
+            @config = YAML.load_file(@config_path)
+            @dspam = DSpamEngine.new(:path => @config[:dspam_path])
+        end
+
+        def process_junk
+            # Create Folder Objects
+            junk = MailDirFolder.new(@config[:maildir] + @config[:junk])
+            corpus = MailDirFolder.new(@config[:maildir] + @config[:corpus])
+
+            # Clean out the Junk Folder
+            @dspam.train_and_clean_folder(junk)
+            @dspam.train_and_clean_folder(corpus)
+        end
+
+        def process_inbox
+            inbox = MailDirFolder.new(@config[:maildir] + @config[:inbox])
+
+            # Feed new messages under the limit in the inbox to the filter as innocent corpus
+            @dspam.train_emails_as_innocent(inbox.emails_newer_than(@config[:limit]))
+        end
+    end
+end
+
+if $0 == __FILE__ then
+    admin = Swallow::Admin.new
+    admin.process_junk
+    admin.process_inbox
+end
+

data/lib/time_extentions.rb

@@ -0,0 +1,98 @@
+#!/usr/bin/ruby -w
+############################################
+# Taken from Ajax Scripts
+# @see http://ajax.stealthsettings.com/ruby/converting-between-time-and-datetime-objects/
+require 'date'
+class Time
+  def to_a_datetime
+    # Convert seconds + microseconds into a fractional number of seconds
+    seconds = sec + Rational(usec, 10**6)
+    # Convert a UTC offset measured in minutes to one measured in a
+    # fraction of a day.
+    offset = Rational(utc_offset, 60 * 60 * 24)
+    DateTime.new(year, month, day, hour, min, seconds, offset)
+  end
+end
+
+class Date
+  def to_gm_time
+    to_time(new_offset, :gm)
+  end
+
+  def to_local_time
+    to_time(new_offset(DateTime.now.offset-offset), :local)
+  end
+
+  private
+  def to_time(dest, method)
+    #Convert a fraction of a day to a number of microseconds
+    usec = (dest.sec_fraction * 60 * 60 * 24 * (10**6)).to_i
+    Time.send(method, dest.year, dest.month, dest.day, dest.hour, dest.min,dest.sec, usec)
+  end
+end
+
+# End Snippet
+############################################
+
+class File
+  def older_than?(date)
+    self.ctime.to_a_datetime < date
+  end
+  def newer_than?(date)
+    self.ctime.to_a_datetime > date
+  end
+end
+
+class Dir
+  # sweep directory of anything over a certain limit old
+  def files_older_than(limit)
+    list = Array.new
+    self.entries.each { |f|
+      filename = File.join(path,f)
+      next if File.directory?(filename)
+      if File.open(filename).older_than?(Date.today - limit) then
+        #puts "File #{filename} is older than limit"
+        list << filename
+      end
+    }
+    return list
+  end
+  def files_newer_than(limit)
+    list = Array.new 
+    self.entries.each { |f|
+      filename = File.join(path,f)
+      next if File.directory?(filename)
+      if File.open(filename).newer_than?(Date.today - limit) then
+        #puts "File #{filename} is newer than limit"
+        list << filename
+      end
+    }
+    return list
+  end
+  def sweep!(limit)
+    files_older_than(limit).each { |f|
+      File.delete(f)
+    } 
+  end
+end
+
+class Regexp
+	def to_reg
+		/#{to_s}/i
+	end
+end
+
+if $0 == __FILE__ then
+  dir = ARGV[0]
+  limit = Integer(ARGV[1])
+  puts "Files Older than #{limit} day(s) old"
+  Dir.open(dir).files_older_than(limit).each { |file|
+    puts "#{file}"
+  }
+  puts "Files Newer than #{limit} days(s) old"
+  Dir.open(dir).files_newer_than(limit).each { |file|
+    puts "#{file}"
+  }
+end
+
+  

data/test/test_folder.rb

@@ -0,0 +1,9 @@
+#!/usr/bin/ruby 
+
+require '../lib/maildir'
+
+if $0 == __FILE__ then
+    include Swallow
+    m = MailDirFolder.new(ARGV[0])
+    m.delete_all_emails
+end

data/test/test_ruleset.rb

@@ -0,0 +1,8 @@
+#!/usr/bin/ruby
+
+require 'rubygems'
+gem 'swallow'
+include 'Swallow'
+
+rules = RuleSet.new("#{ENV['HOME']}/gurgitate/ruleset.yaml")
+

data/test/test_spam.rb

@@ -0,0 +1,12 @@
+#!/usr/bin/ruby
+
+require '../lib/maildir'
+require '../lib/spamdetector'
+
+if $0 == __FILE__ then
+    include Swallow
+    exit(1) unless ARGV.length > 0
+    m = MailDirFolder.new(ARGV[0])
+    d = DSpamEngine.new
+    d.train_and_clean_folder(m)
+end

metadata

@@ -0,0 +1,63 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.2
+specification_version: 1
+name: swallow
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+date: 2007-10-29 00:00:00 -05:00
+summary: A backend IMAP/Maildir Email Sorting/Routing/Cleanup system
+require_paths: 
+- lib
+email: swallow-dev@erik.rainey.name
+homepage: http://erik.rainey.name/swallow
+rubyforge_project: 
+description: 
+autorequire: swallow
+default_executable: 
+bindir: bin
+has_rdoc: false
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: 
+- Erik Rainey
+files: 
+- bin/swallow
+- lib/time_extentions.rb
+- lib/maildir.rb
+- lib/ruleset.rb
+- lib/email.rb
+- lib/swallow.rb
+- lib/spamdetector.rb
+- README
+test_files: 
+- test/test_spam.rb
+- test/test_ruleset.rb
+- test/test_folder.rb
+rdoc_options: []
+
+extra_rdoc_files: 
+- README
+executables: 
+- swallow
+extensions: []
+
+requirements: []
+
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: gurgitate-mail
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Version::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.8.5
+    version: