remailer 0.2.1 → 0.3.0

data/lib/remailer/interpreter.rb

@@ -0,0 +1,253 @@
+class Remailer::Interpreter
+  # == Constants ============================================================
+
+  # == Exceptions ===========================================================
+  
+  class DefinitionException < Exception; end
+
+  # == Submodules ===========================================================
+  
+  autoload(:StateProxy, 'remailer/interpreter/state_proxy')
+  
+  # == Properties ===========================================================
+  
+  attr_reader :delegate
+  attr_reader :state
+  attr_reader :error
+
+  # == Class Methods ========================================================
+  
+  # Defines the initial state for objects of this class.
+  def self.initial_state
+    @initial_state || :initialized
+  end
+  
+  # Can be used to reassign the initial state for this class. May be easier
+  # than re-defining the initial_state method.
+  def self.initial_state=(state)
+    @initial_state = state
+  end
+  
+  # Returns the states that are defined as a has with their associated
+  # options. The default keys are :initialized and :terminated.
+  def self.states
+    @states ||= {
+      :initialized => { },
+      :terminated => { }
+    }
+  end
+  
+  # Returns true if a given state is defined, false otherwise.
+  def self.state_defined?(state)
+    !!self.states[state]
+  end
+  
+  # Returns a list of the defined states.
+  def self.states_defined
+    self.states.keys
+  end
+  
+  # Defines a new state for this class. A block will be executed in the
+  # context of a StateProxy that is used to provide a simple interface to
+  # the underlying options. A block can contain calls to enter and leave,
+  # or default, which do not require arguments, or interpret, which requries
+  # at least one argument that will be the class-specific object to interpret.
+  # Other paramters may be supplied by the class.
+  def self.state(state, &block)
+    config = self.states[state] = { }
+    
+    StateProxy.new(config, &block)
+  end
+  
+  def self.parser_for_spec(spec, &block)
+    case (spec)
+    when nil
+      block
+    when Fixnum
+      lambda do |s|
+        if (s.length >= spec)
+          part = s.slice!(0, spec)
+          block.call(part)
+        end
+      end
+    when Regexp
+      lambda do |s|
+        if (m = spec.match(s))
+          part = m.to_s
+          part = s.slice!(0, part.length)
+          block.call(part)
+        end
+      end
+    else
+      raise DefinitionException, "Invalid specification for parse declaration: #{spec.inspect}"
+    end
+  end
+  
+  # Defines a parser for this interpreter. The supplied block is executed in
+  # the context of a parser instance.
+  def self.parse(spec = nil, &block)
+    @parser = parser_for_spec(spec, &block)
+  end
+  
+  # Assigns the default interpreter.
+  def self.default(&block)
+    @default = block if (block_given?)
+  end
+
+  # Assigns the error handler for when a specific interpretation could not be
+  # found and a default was not specified.
+  def self.on_error(&block)
+    @on_error = block
+  end
+  
+  # Returns the currently defined parser.
+  def self.default_parser
+    @parser ||= lambda { |s| _s = s.dup; s.replace(''); _s }
+  end
+  
+  # Returns the current default_interpreter.
+  def self.default_interpreter
+    @default
+  end
+  
+  # Returns the defined error handler
+  def self.on_error_handler
+    @on_error
+  end
+
+  # == Instance Methods =====================================================
+
+  # Creates a new interpreter with an optional set of options. Valid options
+  # include:
+  # * :delegate => Which object to use as a delegate, if applicable.
+  # * :state => What the initial state should be. The default is :initalized
+  def initialize(options = nil)
+    @delegate = (options and options[:delegate])
+    
+    enter_state(options && options[:state] || self.class.initial_state)
+  end
+  
+  # Enters the given state. Will call the appropriate leave_state trigger if
+  # one is defined for the previous state, and will trigger the callbacks for
+  # entry into the new state. If this state is set as a terminate state, then
+  # an immediate transition to the :terminate state will be performed after
+  # these callbacks.
+  def enter_state(state)
+    if (@state)
+      leave_state(@state)
+    end
+    
+    @state = state
+
+    delegate_call(:interpreter_entered_state, self, @state)
+    
+    trigger_callbacks(state, :enter)
+    
+    # :terminated is the state, :terminate is the trigger.
+    if (@state != :terminated)
+      if (trigger_callbacks(state, :terminate))
+        enter_state(:terminated)
+      end
+    end
+  end
+  
+  # Parses a given string and returns the first interpretable token, if any,
+  # or nil otherwise. The string is not modified.
+  def parse(s)
+    instance_exec(s, &parser)
+  end
+  
+  # Returns the parser defined for the current state, or the default parser.
+  # The default parser simply accepts everything but this can be re-defined
+  # using the class-level parse method.
+  def parser
+    config = self.class.states[@state]
+    
+    config and config[:parser] or self.class.default_parser
+  end
+
+  # Processes a given input string into interpretable tokens, processes these
+  # tokens, and removes them from the input string. If no interpretable
+  # tokens could be found, returns immediately. An optional block can be
+  # given that will be called as each interpretable token is discovered with
+  # the token provided as the argument.
+  def process(s)
+    _parser = parser
+
+    while (parsed = s.empty? ? false : instance_exec(s, &_parser))
+      yield(parsed) if (block_given?)
+
+      interpret(*parsed)
+    end
+  end
+  
+  # Interprets a given object with an optional set of arguments. The actual
+  # interpretation should be defined by declaring a state with an interpret
+  # block defined.
+  def interpret(object, *args)
+    config = self.class.states[@state]
+    callbacks = (config and config[:interpret])
+    
+    if (callbacks)
+      matched, proc = callbacks.find do |on, proc|
+        object == on
+      end
+    
+      if (matched)
+        instance_exec(*args, &proc)
+
+        return true
+      end
+    end
+    
+    if (trigger_callbacks(@state, :default, *([ object ] + args)))
+      # Handled by default
+      true
+    elsif (proc = self.class.default)
+      instance_exec(*args, &proc)
+    else
+      if (proc = self.class.on_error_handler)
+        instance_exec(*args, &proc)
+      end
+
+      @error = "No handler for response #{object.inspect} in state #{@state.inspect}"
+      enter_state(:terminated)
+
+      false
+    end
+  end
+  
+  # Returns true if an error has been generated, false otherwise. The error
+  # content can be retrived by calling error.
+  def error?
+    !!@error
+  end
+  
+protected
+  def delegate_call(method, *args)
+    @delegate and @delegate.respond_to?(method) and @delegate.send(method, *args)
+  end
+  
+  def delegate_assign(property, value)
+    method = :"#{property}="
+    
+    @delegate and @delegate.respond_to?(method) and @delegate.send(method, value)
+  end
+
+  def leave_state(state)
+    trigger_callbacks(state, :leave)
+  end
+  
+  def trigger_callbacks(state, type, *args)
+    config = self.class.states[state]
+    callbacks = (config and config[type])
+    
+    return unless (callbacks)
+
+    callbacks.compact.each do |proc|
+      instance_exec(*args, &proc)
+    end
+    
+    true
+  end
+end

data/lib/remailer/interpreter/state_proxy.rb

@@ -0,0 +1,43 @@
+class Remailer::Interpreter::StateProxy
+  STATIC_CLASSES = [ String, Fixnum, NilClass, TrueClass, FalseClass, Float ].freeze
+  
+  def initialize(options, &block)
+    @options = options
+    
+    instance_eval(&block) if (block_given?)
+  end
+  
+  def parse(spec = nil, &block)
+    @options[:parser] = Remailer::Interpreter.parser_for_spec(spec, &block)
+  end
+  
+  def enter(&block)
+    @options[:enter] ||= [ ]
+    @options[:enter] << block
+  end
+  
+  def interpret(response, &block)
+    @options[:interpret] ||= [ ]
+    @options[:interpret] << [ response, block ]
+  end
+  
+  def default(&block)
+    @options[:default] ||= [ ]
+    @options[:default] << block
+  end
+
+  def leave(&block)
+    @options[:leave] ||= [ ]
+    @options[:leave] << block
+  end
+  
+  def terminate(&block)
+    @options[:terminate] ||= [ ]
+    @options[:terminate] << block
+  end
+
+protected
+  def rebind(options)
+    @options = options
+  end
+end

data/remailer.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{remailer}
-  s.version = "0.2.1"
+  s.version = "0.3.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Scott Tadman"]
-  s.date = %q{2010-11-22}
+  s.date = %q{2010-12-02}
   s.description = %q{EventMachine capable SMTP engine}
   s.email = %q{scott@twg.ca}
   s.extra_rdoc_files = [
@@ -23,8 +23,18 @@ Gem::Specification.new do |s|
      "VERSION",
      "lib/remailer.rb",
      "lib/remailer/connection.rb",
+     "lib/remailer/connection/smtp_interpreter.rb",
+     "lib/remailer/connection/socks5_interpreter.rb",
+     "lib/remailer/interpreter.rb",
+     "lib/remailer/interpreter/state_proxy.rb",
      "remailer.gemspec",
+     "test/config.example.rb",
      "test/helper.rb",
+     "test/unit/remailer_connection_smtp_interpreter_test.rb",
+     "test/unit/remailer_connection_socks5_interpreter_test.rb",
+     "test/unit/remailer_connection_test.rb",
+     "test/unit/remailer_interpreter_state_proxy_test.rb",
+     "test/unit/remailer_interpreter_test.rb",
      "test/unit/remailer_test.rb"
   ]
   s.homepage = %q{http://github.com/twg/remailer}
@@ -33,7 +43,13 @@ Gem::Specification.new do |s|
   s.rubygems_version = %q{1.3.7}
   s.summary = %q{Reactor-Ready SMTP Mailer}
   s.test_files = [
-    "test/helper.rb",
+    "test/config.example.rb",
+     "test/helper.rb",
+     "test/unit/remailer_connection_smtp_interpreter_test.rb",
+     "test/unit/remailer_connection_socks5_interpreter_test.rb",
+     "test/unit/remailer_connection_test.rb",
+     "test/unit/remailer_interpreter_state_proxy_test.rb",
+     "test/unit/remailer_interpreter_test.rb",
      "test/unit/remailer_test.rb"
   ]
 

data/test/config.example.rb

@@ -0,0 +1,17 @@
+TestConfig.smtp_server = {
+  :host => "smtp.example.com",
+  :identifier => "smtp.example.com"
+} 
+
+TestConfig.public_smtp_server = {
+  :host => "smtp.gmail.com",
+  :identifier => "mx.google.com",
+  :username => "--your--username--gmail.com",
+  :password => "--your--password--",
+  :port => 587
+}
+
+TestConfig.proxy_server = "proxy.example.com"
+
+TestConfig.recipient = "--your--email--"
+TestConfig.sender = "--your--email--"

data/test/helper.rb

@@ -17,6 +17,39 @@ end
 
 require 'remailer'
 
+class Proc
+  def inspect
+    "\#<Proc: #{object_id}>"
+  end
+end
+
+unless (Hash.respond_to?(:slice))
+  class Hash
+    def slice(*keys)
+      keys.inject({ }) do |h, k|
+        h[k] = self[k]
+        h
+      end
+    end
+  end
+end
+
+module TestTriggerHelper
+  def self.included(base)
+    base.class_eval do
+      attr_reader :triggered
+      
+      def triggered
+        @triggered ||= Hash.new(false)
+      end
+      
+      def trigger(action, value = true)
+        self.triggered[action] = value
+      end
+    end
+  end
+end
+
 class Test::Unit::TestCase
   def engine
     exception = nil
@@ -24,8 +57,12 @@ class Test::Unit::TestCase
     ThreadsWait.all_waits(
       Thread.new do
         Thread.abort_on_exception = true
+
         # Create a thread for the engine to run on
-        EventMachine.run
+        begin
+          EventMachine.run
+        rescue Object => exception
+        end
       end,
       Thread.new do
         # Execute the test code in a separate thread to avoid blocking
@@ -34,7 +71,12 @@ class Test::Unit::TestCase
           yield
         rescue Object => exception
         ensure
-          EventMachine.stop_event_loop
+          begin
+            EventMachine.stop_event_loop
+          rescue Object
+            # Shutting down may trigger an exception from time to time
+            # if the engine itself has failed.
+          end
         end
       end
     )
@@ -61,6 +103,23 @@ class Test::Unit::TestCase
       end
     end
   end
+
+  def assert_mapping(map, &block)
+    result_map = map.inject({ }) do |h, (k,v)|
+      h[k] = yield(k)
+      h
+    end
+    
+    differences = result_map.inject([ ]) do |a, (k,v)|
+      if (v != map[k])
+        a << k
+      end
+
+      a
+    end
+    
+    assert_equal map, result_map, "Difference: #{map.slice(*differences).inspect} vs #{result_map.slice(*differences).inspect}"
+  end
 end
 
 require 'ostruct'