sortah 0.5.0

data/bin/sortah

@@ -0,0 +1,33 @@
+#!/usr/bin/env ruby
+require 'trollop'
+require 'sortah'
+require 'digest/sha1'
+
+opts = Trollop::options do
+  banner 'Sortah'
+  opt :rc, "path to your sortah files", :default => "#{ENV['HOME']}/.sortahrc"
+  opt :"dry-run", "Do not execute any changes" 
+  opt :verbose  , "Increase verbosity"
+end
+
+puts "Dry-run mode" if opts[:"dry-run"]
+
+puts "Reading mail" if opts[:verbose]
+email = Mail.new do
+  body ARGF.read
+end
+
+load File.expand_path(opts[:rc])
+
+dest = sortah.sort(email).full_destination
+puts "writing email to: #{dest}" if opts[:"dry-run"] || opts[:verbose]
+
+exit 0 if opts[:"dry-run"]
+
+#no need to check for dry-run here, we would have exited otherwise
+system "mkdir -p #{dest}" 
+File.open("#{dest}/#{Digest::SHA1.hexdigest(email.to_s)}.eml", 'w') do |f|
+  f << email.to_s
+end
+puts "wrote file to #{dest}" if opts[:verbose]
+

data/lib/sortah.rb

@@ -0,0 +1,10 @@
+require 'sortah/version'
+require 'sortah/parser'
+require 'sortah/patches'
+require 'sortah/errors'
+require 'sortah/cleanroom'
+require 'sortah/handler'
+require 'sortah/components'
+require 'sortah/email'
+
+require 'mail'

data/lib/sortah/cleanroom.rb

@@ -0,0 +1,47 @@
+module Sortah
+
+  class FinishedExecution < Exception
+  end
+  
+  
+  class CleanRoom < BasicObject
+    def self.sort(email, context)
+      new(email, context).sort
+    end
+
+    def sort
+      until @pointer.is_a?(Destination) do
+        run!(@pointer) rescue FinishedExecution
+      end 
+      self
+    end
+
+    def metadata(key)
+      email.send(key)
+    end
+
+    def destination 
+      @pointer if @pointer.is_a? Destination
+    end
+
+    private 
+
+    def email; @__email__; end
+
+    def run!(component) 
+      @pointer.run_dependencies!(email, @__context__.lenses)
+      self.instance_eval &component.block
+    end
+
+    def send_to(dest)
+      @pointer = @__context__.routers[dest] || @__context__.destinations[dest]
+      throw FinishedExecution
+    end
+
+    def initialize(email, context)
+      @__email__ = Email.wrap(email)
+      @__context__ = context
+      @pointer = context.routers[:root]
+    end
+  end
+end

data/lib/sortah/components.rb

@@ -0,0 +1,3 @@
+require 'sortah/components/destination'
+require 'sortah/components/lens'
+require 'sortah/components/router'

data/lib/sortah/components/destination.rb

@@ -0,0 +1,41 @@
+require 'sortah/util/component_collection'
+
+module Sortah
+  class Destinations < ComponentCollection
+    def [](key)
+      value = self.fetch(key)
+      if value.alias? 
+        self.fetch(value.path)
+      else
+        value
+      end
+    end
+  end
+
+  class Destination
+    attr_reader :name, :path
+
+    def initialize(name, path)
+      @name = name
+      @path = if path.class == Hash then path[:abs] else path end
+    end
+
+    def defined?(context)
+      context.include?(@name)
+    end
+
+    def alias?
+      @path.class == Symbol
+    end
+
+    def ==(other)
+      (other.class == Destination && other.name == @name && other.path == @path) ||
+      @path == other || 
+      super
+    end
+
+    def to_s
+      @path
+    end
+  end
+end

data/lib/sortah/components/lens.rb

@@ -0,0 +1,49 @@
+require 'sortah/util/component_collection'
+require 'sortah/util/component'
+
+module Sortah
+  class Lenses < ComponentCollection
+    def clear_state!
+      self.each_value { |lens| lens.clear_state! }
+    end
+  end
+
+  class Lens < Component
+    def provides_value? 
+      !@opts[:pass_through]
+    end
+
+    def valid?(context)
+      dependencies.each do |lens|
+        raise ParseErrorException unless context.include? lens
+      end
+    end
+
+    def run!(email, context)
+      @email = email
+      run_dependencies!(email, context)
+      return if already_ran?
+      result = run_block!
+      email.metadata(name, result) if provides_value?
+    end
+
+    def clear_state!; @ran = false; end
+
+    private 
+
+    def mark_as_run!; @ran = true end
+    def already_ran?; @ran end
+
+    # used for context evaluation
+    def email; @email; end
+
+    def provides_value? 
+      !@opts[:pass_through]
+    end
+
+    def run_block!
+      mark_as_run!
+      self.instance_eval &block
+    end
+  end
+end

data/lib/sortah/components/router.rb

@@ -0,0 +1,13 @@
+require 'sortah/util/component_collection'
+require 'sortah/util/component'
+
+module Sortah 
+  class Routers < ComponentCollection
+    def has_root?
+      self.fetch(:root, false)
+    end
+  end
+
+  class Router < Component 
+  end
+end

data/lib/sortah/email.rb

@@ -0,0 +1,31 @@
+require 'delegate'
+require 'mail'
+module Sortah
+  class Email < DelegateClass(Mail)
+    def self.wrap(context, metadata = {})
+      Email.new(context, metadata)
+    end
+
+    def method_missing(meth, *args, &blk)
+      return @metadata[meth] if has_data_for?(meth)
+      super rescue nil
+    end
+
+    def metadata(key, value)
+      @metadata[key] = value
+    end
+
+    private
+
+    def has_data_for?(meth)
+      @metadata.keys.include?(meth) and 
+      @metadata[meth] != :pass_through 
+    end
+
+    def initialize(context, metadata)
+      @metadata = metadata
+      super(context)
+    end
+
+  end
+end

data/lib/sortah/errors.rb

@@ -0,0 +1,15 @@
+module Sortah
+  class ParseErrorException < Exception
+    alias_method :to_s, :inspect
+    def inspect
+      "<Sortah::ParseErrorException>"
+    end
+  end
+
+  class NoRootRouterException < Exception
+    alias_method :to_s, :inspect
+    def inspect
+      "<Sortah::NoRootRouterException>"
+    end
+  end
+end

data/lib/sortah/handler.rb

@@ -0,0 +1,46 @@
+require 'sortah/components'
+module Sortah
+  class Handler
+    def self.build_from(context)
+      new(context)
+    end
+
+    def sort(context)
+      raise NoRootRouterException unless @routers.has_root?    
+      clear_state!
+      @result = CleanRoom.sort(context, self)
+      self
+    end
+
+    attr_reader :destinations, :lenses, :routers, :maildir
+
+    def metadata(key)
+      @result.metadata(key)
+    end
+
+    def destination
+      @result.destination
+    end
+
+    def full_destination
+      maildir + destination.to_s
+    end
+
+    private
+
+    def clear_state! 
+      @lenses.clear_state!
+    end
+
+    def clear_state! 
+      @lenses.clear_state!
+    end
+
+    def initialize(context)
+      @destinations = context.destinations
+      @lenses       = context.lenses
+      @routers      = context.routers
+      @maildir      = context.maildir
+    end
+  end
+end

data/lib/sortah/parser.rb

@@ -0,0 +1,57 @@
+require 'sortah/components'
+
+require 'singleton'
+module Sortah
+  class Parser
+    include Singleton
+
+    def self.clear!
+      self.instance.clear!
+    end
+
+    ##object-level interaction
+    attr_reader :destinations, :lenses, :routers
+    
+    def clear!
+      @destinations = Destinations.new
+      @lenses = Lenses.new
+      @routers = Routers.new
+    end
+
+    def initialize
+      clear!
+    end
+
+    def handle(&block)
+      self.instance_eval &block
+      valid?
+    end
+
+    def valid?
+      @lenses.valid?
+      @routers.valid?
+      @destinations.valid?
+    end
+   
+    ## metadata/config data
+
+    #double-duty getter/setter
+    def maildir(maildir_path = nil)
+      @maildir = maildir_path if maildir_path
+      @maildir
+    end
+
+    ## language elements
+    def destination(name, args)
+      @destinations << Destination.new(name, args)
+    end
+
+    def lens(name, opts = {}, &block)
+      @lenses << Lens.new(name, opts, block)
+    end
+
+    def router(name = :root, opts = {}, &block)
+      @routers << Router.new(name, opts, block)
+    end
+  end
+end

data/lib/sortah/patches.rb

@@ -0,0 +1,7 @@
+module Kernel
+  def sortah(&block)
+    instance = Sortah::Parser.instance
+    instance.handle &block if block_given? 
+    Sortah::Handler.build_from(instance)
+  end
+end

data/lib/sortah/util/component.rb

@@ -0,0 +1,28 @@
+module Sortah
+  class Component 
+    attr_reader :name, :block
+
+    def initialize(name, opts = {}, *potential_block) 
+      @name = name
+      @opts = opts
+      @block = potential_block.first unless potential_block.empty?
+    end
+
+    def run_dependencies!(email, context)
+      dependencies(context).each { |lens| lens.run!(email, context) }
+    end
+
+    def defined?(context)
+      !!context[name]
+    end
+
+    protected 
+
+    def dependencies(context = nil)
+      lenses = (@opts[:lenses] || [])
+      return lenses if context.nil?
+      lenses.map { |lens| context[lens] }
+    end
+  end
+  
+end

data/lib/sortah/util/component_collection.rb

@@ -0,0 +1,22 @@
+module Sortah
+  class ComponentCollection < Hash
+    def <<(component)
+      return unless component.respond_to? :name
+      raise ParseErrorException if component.defined?(self)
+      self[component.name] = component
+    end
+
+    def valid?
+      return if self.empty?
+      self.each_value do |value|
+        # someone might have registered a singleton method? 
+        next unless value.respond_to? :valid? 
+        value.valid?(self)
+      end
+    end
+
+    def defined?(dest)
+      self.keys.include?(dest)
+    end
+  end
+end

data/lib/sortah/version.rb

@@ -0,0 +1,3 @@
+module Sortah
+  VERSION = "0.5.0"
+end

data/sortah.gemspec

@@ -0,0 +1,31 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "sortah/version"
+
+Gem::Specification.new do |s|
+  s.name        = "sortah"
+  s.version     = Sortah::VERSION
+  s.authors     = ["Joe Fredette"]
+  s.email       = ["jfredett@gmail.com"]
+  s.homepage    = "http://www.github.com/jfredett/sortah"
+  s.summary     = %q{For sortin' your email}
+  s.description = %q{
+    Sortah provides a simple, declarative internal DSL for sorting 
+    your email. It provides an executable which may serve as an external
+    mail delivery agent for such programs as `getmail`. Finally, since
+    your sorting logic is just Plain Old Ruby Code (PORC, as I like to call it).
+    You have access to 100% of ruby as needed, including all of it's 
+    object oriented goodness, it's wonderful community of gems, and it's 
+    powerful metaprogramming ability.
+  }
+
+  s.rubyforge_project = "sortah"
+
+  s.add_dependency "mail"
+  s.add_dependency "trollop"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end