sortah 0.5.0

data/spec/bin_spec.rb

@@ -0,0 +1,54 @@
+def run_with(arg, email = "")
+  #uses the sortah defn in spec/fixtures/rc
+  cmd =<<-CMD
+bundle exec bin/sortah #{arg} --rc "spec/fixtures/rc" <<-EMAIL
+#{email}
+EMAIL
+CMD
+  result = `#{cmd}`
+
+  { result: result, status: $?.to_i }
+end
+
+
+describe "the sortah executable" do
+  before :all do
+    Mail.defaults do
+      delivery_method :test
+    end
+
+    @email = Mail.new do
+      to 'testa@example.com'
+      from 'chuck@nope.com'
+      subject "Taximerdizin'"
+      body <<-TXT
+          OJAI VALLEY TAXIDERMY
+
+          BET YOU THOUGHT THIS EMAIL WAS REAL
+
+          NOPE. CHUCK TESTA
+      TXT
+    end
+  end
+
+  before :each do
+    Sortah::Parser.clear!
+  end
+
+  context "when executing in dry-run mode, " do
+    it "should have a dry-run mode" do
+      cmd = run_with("--dry-run")
+      cmd[:result].should =~ /Dry-run mode/
+      cmd[:status].should == 0
+    end
+
+    it "should not write any files when in dry-run mode" do
+      run_with('--dry-run', @email.to_s)
+      Dir['/tmp/mail/*'].size.should == 0
+    end
+
+    it "should print to STDOUT the location it intends to write the file" do
+      run_with('--dry-run', @email.to_s)[:result].should =~ %r|writing email to: /tmp/\.mail/foo/|
+    end
+  end
+end

data/spec/destination_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+describe Sortah::Destination do
+
+  context "when creating a destination" do
+    it "should be able to show me it's destination path" do
+      dest = Sortah::Destination.new(:foo, "bar")  
+      dest.path.should == "bar"
+    end
+  end
+
+  context "when comparing a destination with another object, " do
+    it "should be equal to itself" do
+      dest = Sortah::Destination.new(:foo, "bar")  
+      (dest == dest).should be_true
+    end
+
+    it "should not be equal to a destination which has a different path" do
+      dest = Sortah::Destination.new(:foo, "bar")  
+      dest2 = Sortah::Destination.new(:bar, "baz")
+      (dest == dest2).should_not be_true
+    end
+
+    it "should not be equal to a destination which has the same path, but different name" do
+      dest = Sortah::Destination.new(:foo, "baz")  
+      dest2 = Sortah::Destination.new(:bar, "baz")
+      (dest == dest2).should_not be_true
+    end
+
+    it "should be equal to an equivalent destination" do
+      dest = Sortah::Destination.new(:foo, "baz")
+      dest2 = Sortah::Destination.new(:foo, "baz")
+      (dest == dest2).should be_true
+    end
+
+    it "should be equal to a string which is identical to the absolute path it describes" do
+      dest = Sortah::Destination.new(:foo, "baz")
+      (dest == "baz").should be_true
+    end
+  end
+
+end

data/spec/email_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+describe Sortah::Email do
+  before :each do
+    @email = Sortah::Email.wrap(Mail.new)
+  end
+
+  it "should proxy the Mail class" do
+    (Mail.new.methods - Object.methods).each do |method|
+      @email.should respond_to method
+    end
+  end
+end
+

data/spec/fixtures/rc

@@ -0,0 +1,8 @@
+sortah do
+  maildir '/tmp/.mail/'
+  destination :foo, 'foo/'
+
+  router do
+    send_to :foo
+  end
+end

data/spec/parser_spec.rb

@@ -0,0 +1,270 @@
+require 'spec_helper'
+
+describe Sortah::Parser do
+  context "when parsing language components, " do
+    before :each do
+      Sortah::Parser.clear!
+    end
+    
+    context "when parsing destinations, " do
+      it "should provide an environment for definiton" do
+        expect {
+          sortah do
+          end 
+        }.should_not raise_error
+        sortah.should_not be_nil
+      end
+
+      it "should parse defined 'simple' destinations"  do
+        expect {
+          sortah do
+            destination :place, "somewhere/"
+          end
+        }.should_not raise_error
+        sortah.destinations[:place].should == "somewhere/"
+      end
+
+      it "should parse defined 'absolute path' destinations" do
+        expect {
+          sortah do
+            destination :place, :abs => "/home/user/.mail/.somewhere.else/"
+          end
+        }.should_not raise_error
+        sortah.destinations[:place].should == "/home/user/.mail/.somewhere.else/"
+      end
+
+      it "should parse defined 'alias' destinations in a dereferenced way" do
+        expect {
+          sortah do
+            destination :place, "somewhere/"
+            destination :other_place, :place
+          end
+        }.should_not raise_error
+        sortah.destinations[:other_place].should == "somewhere/"
+      end
+
+      it "should throw a parse error when you try to redefine a destination" do
+        expect { 
+          sortah do
+            destination :same_dest, "dest/"
+            destination :same_dest, "dest/"
+          end
+        }.should raise_error Sortah::ParseErrorException
+      end
+
+    end
+
+    context "when parsing lenses," do
+
+      it "should parse a lens definition" do
+        expect {
+          sortah do
+            lens :test_value do
+              1 
+            end
+          end
+        }.should_not raise_error
+      end
+
+      it "should parse a lens definition that depends on another lens" do
+        expect {
+          sortah do
+            lens :dep do
+              1
+            end
+
+            lens :test_value, lenses: [:dep] do
+              2
+            end
+          end
+        }.should_not raise_error
+      end
+
+      it "should throw a parse error if you try to define the same lens (by name) twice" do
+        expect {
+          sortah do
+            lens :same_name do
+            end
+            lens :same_name do
+            end
+          end
+        }.should raise_error Sortah::ParseErrorException
+      end
+      
+      it "should throw a parse error if you try to reference a lens which does not exist" do
+        expect {
+          sortah do
+            lens :other_name, :lenses => [:non_existant] do
+            end
+          end
+        }.should raise_error Sortah::ParseErrorException
+
+      end
+
+      it "should not throw a parse error if you try to forward-reference a lens" do
+        expect {
+          sortah do
+            lens :forward_reference, :lenses => [:ahead] do
+            end
+            lens :ahead do
+            end
+          end
+        }.should_not raise_error Sortah::ParseErrorException
+      end
+
+      it "should not throw a parse error if you have a cyclic-lens dependency" do
+        expect {
+          sortah do
+            lens :circle_one, :lenses => [:circle_two] do
+            end
+            lens :circle_two, :lenses => [:circle_one] do
+            end
+          end
+        }.should_not raise_error Sortah::ParseErrorException
+      end
+
+    end
+
+    context "when parsing routers, " do
+
+      it "should parse a router definition" do
+        expect {
+          sortah do
+            router :test_router do
+            end
+          end
+        }.should_not raise_error
+
+      end
+
+      it "should parse a root-router definition" do
+        expect {
+          sortah do
+            router do
+            end
+          end
+        }.should_not raise_error
+      end
+
+      it "should parse a router with lenses" do
+        expect {
+          sortah do
+            lens :foo do
+            end
+
+            router :test_router, :lenses => [:foo] do
+            end
+          end
+        }.should_not raise_error
+      end
+
+      it "should parse a root-router with lenses" do
+        expect {
+          sortah do
+            lens :foo do
+            end
+            
+            router :lenses => [:foo] do
+            end
+          end
+        }.should_not raise_error
+      end
+
+      it "should parse a router with a forward reference to a lens" do
+        expect {
+          sortah do
+            router :foo_router, :lenses => [:foo] do
+            end
+
+            lens :foo do
+            end
+          end
+        }.should_not raise_error
+      end
+      
+      it "should parse a root-router with a forward reference to a lens" do
+        expect {
+          sortah do
+            router :lenses => [:foo] do
+            end
+
+            lens :foo do
+            end
+          end
+        }.should_not raise_error
+      end
+
+    end
+
+    context "when dealing in general with sortah, " do
+
+      it "should maintain one state across multiple sortah blocks" do
+        expect {
+          sortah do
+            destination :place, "somewhere/"
+          end
+        }.should_not raise_error
+
+        expect {
+          sortah do
+            destination :new_place, :place
+          end
+        }.should_not raise_error
+
+        sortah.destinations[:place].should == "somewhere/"
+        sortah.destinations[:new_place].should == "somewhere/"
+      end
+
+      it "should allow for configuration" do
+        sortah do
+          maildir "/home/user/.mail" #mail directory, maildir format
+        end
+        sortah.maildir.should == "/home/user/.mail"
+      end
+
+      it "should use the last defined maildir" do
+        sortah do
+          maildir "/home/user/.mail/work"
+          maildir "/home/user/.mail/personal"
+        end
+        sortah.maildir.should == "/home/user/.mail/personal"
+      end
+
+    end
+
+    #acceptance criteria
+    it "should parse an example sortah file, which contains all of the language elements" do
+      expect { 
+        sortah do
+          destination :place, "somewhere"
+          destination :devnull, :abs => "/dev/null"
+          destination :bitbucket, :devnull
+
+          lens :random_value do
+            rand
+          end
+
+          lens :random_spam_value, :lenses => [:random_value] do
+            email.random_value * 10
+          end
+
+          lens :also_depends_on_random_value, :lenses => [:random_value] do
+            email.random_value * 100
+          end
+
+          router :root, :lenses => [:random_spam_value] do
+            if email.random_spam_value > 0.5
+              send_to :other_router
+            else
+              send_to :bitbucket
+            end
+          end
+
+          router :other_router, :lenses => [:also_depends_on_random_value] do
+            send_to :place
+          end
+        end
+      }.should_not raise_error
+    end
+  end
+end

data/spec/semantic_spec.rb

@@ -0,0 +1,310 @@
+require 'spec_helper'
+require 'mail'
+
+#TODO: Move to spec_helper?
+def basic_sortah_definition
+  sortah do
+    maildir "/home/jfredett/.mail"
+    destination :foo, "foo/"
+    destination :bar, "bar/"
+    router do
+      if email.from.any? { |sender| sender =~ /chuck/ } 
+        send_to :foo
+      else
+        send_to :bar
+      end
+    end
+  end
+end
+
+describe Sortah do
+  context "when sorting an email" do
+    before :all do
+      Mail.defaults do
+        delivery_method :test
+      end
+
+      @email = Mail.new do
+        to 'testa@example.com'
+        from 'chuck@nope.com'
+        subject "Taximerdizin'"
+        body <<-TXT
+          OJAI VALLEY TAXIDERMY
+
+          BET YOU THOUGHT THIS EMAIL WAS REAL
+
+          NOPE. CHUCK TESTA
+        TXT
+      end
+
+      @reply_email = Mail.new do
+        to 'chuck@nope.com'
+        from 'jgf@somewhere.com'
+        subject "Re: Taximerdizin'"
+        reply_to 'chuck@nope.com'
+        body <<-TXT
+        > OJAI VALLEY TAXIDERMY
+        >
+        > BET YOU THOUGHT THIS EMAIL WAS REAL
+        >
+        > NOPE. CHUCK TESTA
+
+        Do you taxidermize pets? 
+        TXT
+      end
+    end
+
+    before :each do
+      Sortah::Parser.clear!
+    end
+
+    it "should provide a way to sort a single email" do
+      sortah.should respond_to :sort
+    end
+
+    it "should throw a sematic error when calling #sort with no root router is provided" do
+      sortah do 
+        destination :foo, "foo/"
+        router :not_root do
+          send_to :foo
+        end
+      end
+      expect { sortah.sort(@email) }.should raise_error Sortah::NoRootRouterException
+    end
+
+    describe "#sort" do
+      it "should return an object which responds to #destination" do
+        basic_sortah_definition
+        sortah.sort(@email).should respond_to :destination
+      end
+
+      it "should return an object which responds to #metadata" do
+        basic_sortah_definition
+        sortah.sort(@email).should respond_to :metadata
+      end
+      
+      it "should sort emails based on the sortah definitions" do
+        basic_sortah_definition
+        sortah.sort(@email).destination.should == "foo/"
+        sortah.sort(@reply_email).destination.should == "bar/"
+      end
+
+      it "should defer to a second router if it is sent to one" do
+        sortah do
+          destination :foo, "foo/"
+          destination :bar, "bar/"
+          
+          router do
+            if email.from.any? { |sender| sender =~ /chuck/ }
+              send_to :foo
+            else
+              send_to :secondary_router
+            end
+          end
+
+          router :secondary_router do
+            send_to :bar
+          end
+        end
+        
+        sortah.sort(@email).destination.should == "foo/"
+        sortah.sort(@reply_email).destination.should == "bar/"
+      end
+
+      it "should run dependent lenses for the root router" do
+        sortah do
+          destination :foo, "foo/"
+         
+          lens :senders do
+            email.from.map { |s| s.split('@').first }
+          end
+
+          router :root, :lenses => [:senders] do
+            send_to :foo
+          end
+        end
+        sortah.sort(@email).metadata(:senders).should == ["chuck"]
+      end
+
+      it "should run dependent lenses for the non-root router, but only if the router gets called" do
+        sortah do
+          destination :foo, "foo/"
+         
+          lens :senders do
+            email.from.map { |s| s.split('@').first }
+          end
+
+          lens :never_called do
+            "This should never be called, since the router that depends on it never gets called"
+          end
+
+          router :root, :lenses => [:senders] do
+            send_to :foo
+          end
+
+          router :bar, :lenses => [:never_called] do
+            "doesn't matter what I put in here"
+          end
+        end
+        sortah.sort(@email).metadata(:never_called).should be_nil
+      end
+
+      it "should never run a lens that isn't a dependency" do
+        sortah do
+          destination :foo, "foo/"
+         
+          lens :senders do
+            email.from.map { |s| s.split('@').first }
+          end
+
+          lens :never_called do
+            "This should never be called, since the router that depends on it never gets called"
+          end
+
+          router :root, :lenses => [:senders] do
+            send_to :foo
+          end
+        end
+        sortah.sort(@email).metadata(:never_called).should be_nil
+      end
+
+      it "should run provide access to the metadata generated by a lens through the email object" do
+        sortah do
+          destination :foo, "foo/"
+          destination :bar, "bar/"
+         
+          lens :senders do
+            email.from.map { |s| s.split('@').first }
+          end
+
+          lens :never_called do
+            "This should never be called, since the router that depends on it never gets called"
+          end
+
+          router :root, :lenses => [:senders] do
+            if email.senders.include? "chuck"
+              send_to :foo
+            else
+              send_to :bar
+            end
+          end
+        end
+        sortah.sort(@email).destination.should == "foo/"
+        sortah.sort(@reply_email).destination.should == "bar/"
+      end
+
+      it "should run subdependencies of lenses" do
+        sortah do
+          destination :foo, "foo/"
+          destination :bar, "bar/"
+         
+          lens :senders, :lenses => [:sub_dep] do
+            email.from.map { |s| s.split('@').first }
+          end
+
+          lens :sub_dep do
+            "Sub Dep Ran"
+          end
+
+          router :root, :lenses => [:senders] do
+            if email.senders.include? "chuck"
+              send_to :foo
+            else
+              send_to :bar
+            end
+          end
+        end
+        sortah.sort(@email).metadata(:sub_dep).should == "Sub Dep Ran"
+      end
+
+      it "should not run the same lens twice" do
+        $count = 0 #evil, pure evil
+        sortah do
+          destination :bar, "bar/"
+         
+          lens :inc do
+            $count += 1
+          end
+
+          router :root, :lenses => [:inc] do
+            send_to :baz
+          end
+
+          router :baz, :lenses => [:inc] do
+            send_to :bar
+          end
+        end
+
+        sortah.sort(@email).metadata(:inc).should == 1
+
+        $count = nil #undefine $count
+      end
+
+      it "should not set any metadata for a :pass_through lens" do
+        sortah do
+          destination :foo, "foo/"
+         
+          lens :passthrough, :pass_through => true do
+            "some external service call"
+          end
+
+          router :root, :lenses => [:passthrough] do
+            send_to :baz
+          end
+
+          router :baz, :lenses => [:passthrough] do
+            send_to :foo
+          end
+        end
+        sortah.sort(@email).metadata(:passthrough).should be_nil
+      end
+
+      it "should not run a pass_through lens more than once" do
+        $count = 0
+        sortah do
+          destination :foo, "foo/"
+         
+          lens :passthrough, :pass_through => true do
+            $count += 1
+          end
+
+          router :root, :lenses => [:passthrough] do
+            send_to :baz
+          end
+
+          router :baz, :lenses => [:passthrough] do
+            send_to :foo
+          end
+        end
+        sortah.sort(@email)
+        $count.should == 1
+      end
+
+      it "should execute only until the first #send_to call" do
+        sortah do 
+          destination :foo, "foo/"
+          router do
+            send_to :foo
+            throw Exception
+          end
+        end
+        expect { sortah.sort(@email) }.should_not raise_error Exception
+        sortah.sort(@email).destination.should == "foo/"
+      end
+
+      describe "#full_destination" do
+        it "should return the full path (including the maildir basepath) to which an email will be routed" do
+          sortah do 
+            maildir '/tmp/'
+            destination :foo, "foo/"
+            router do
+              send_to :foo
+            end
+          end
+          sortah.sort(@email).full_destination.should == "/tmp/foo/"
+          
+        end
+      end
+    end
+  end
+end