messed 0.0.1

data/Gemfile

@@ -0,0 +1,8 @@
+source 'http://gems.github.com'
+source 'http://gemcutter.org'
+
+gem 'methodmissing-hwia'
+gem 'hashify'
+gem 'em-http-request'
+gem 'em-jack'
+gem 'dressmaker'

data/README.rdoc

@@ -0,0 +1,22 @@
+= Messed
+
+== Short messaging framework
+
+We deal with short messages all the time. Email, SMS, twitter and XMPP are examples of such. This framework attempts to make it simple to deal with these various types of services.
+
+== Getting started
+
+Generate your app, fill it in.
+
+== Topology
+
+  /----------\                   Worker                   /----------\
+  |          |    /-------\      Worker     /-------\     |          |
+  | Incoming |==> | Queue | ==>  Worker ==> | Queue | ==> | Outgoing |
+  |          |    \-------/      Worker     \-------/     |          |
+  \----------/                   Worker                   \----------/
+
+== Sample app
+
+Let's listen to every tweet your friend sends you, and, if its in delicious, add it, otherwise, reply with a message saying how much you enjoyed that link.
+

data/Rakefile

@@ -0,0 +1,76 @@
+libdir = File.expand_path("lib")
+$:.unshift(libdir) unless $:.include?(libdir)
+
+require 'messed'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |s|
+    s.name = "messed"
+    s.description = s.summary = "A framework for short message paradigms"
+    s.email = "joshbuddy@gmail.com"
+    s.homepage = "http://github.com/joshbuddy/messed"
+    s.authors = ["Joshua Hull"]
+    s.files = FileList["[A-Z]*", "{lib,spec,bin,application_spec,patterns}/**/*"]
+    s.add_dependency 'eventmachine'
+    s.add_dependency 'em-http-request', '>=0.2.6'
+    s.add_dependency 'em-beanstalk', '>=0.0.6'
+    s.add_dependency 'hashify', '>=0.0.2'
+    s.add_dependency 'hwia', '>=1.0.2'
+    s.add_dependency 'twitter-stream', '>=0.1.3'
+    s.add_dependency 'activesupport'
+    s.add_dependency 'dressmaker', '>=0.0.3'
+    s.add_dependency 'beanstalk-client'
+    s.add_dependency 'rspec'
+    s.add_dependency 'json'
+    s.add_dependency 'thor'
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+end
+
+require 'spec'
+require 'spec/rake/spectask'
+task :spec => ['spec:all', 'spec:application']
+namespace(:spec) do
+  Spec::Rake::SpecTask.new(:all) do |t|
+    t.spec_opts ||= []
+    t.spec_opts << "-rubygems"
+    t.spec_opts << "--options" << "spec/spec.opts"
+    t.spec_files = FileList['spec/**/*_spec.rb']
+  end
+
+  Spec::Rake::SpecTask.new(:application) do |t|
+    ENV['MESSED_HOME'] = '..'
+    t.ruby_opts ||= []
+    t.ruby_opts << '-Capplication_spec'
+    t.spec_opts ||= []
+    t.spec_opts << "-rubygems"
+    t.spec_opts << "--options" << "spec/spec.opts"
+    t.spec_files = FileList['application_spec/spec/**/*_spec.rb'].map{|f| f[/application_spec\/(.*)/, 1]}
+  end
+
+end
+
+desc "Run all examples with RCov"
+Spec::Rake::SpecTask.new('spec_with_rcov') do |t|
+  t.spec_files = FileList['spec/**/*.rb']
+  t.rcov = true
+  t.rcov_opts = ['--exclude', 'spec']
+end
+
+require 'rake/rdoctask'
+desc "Generate documentation"
+Rake::RDocTask.new do |rd|
+  rd.main = "README.rdoc"
+  rd.rdoc_files.include("README.rdoc", "lib/**/*.rb")
+  rd.rdoc_dir = 'rdoc'
+end
+
+begin
+  require 'code_stats'
+  CodeStats::Tasks.new
+rescue LoadError
+  puts "Code stats not available, install it with gem install code_stats"
+end

data/VERSION

@@ -0,0 +1 @@
+0.0.1

data/application_spec/Rakefile

@@ -0,0 +1,12 @@
+require 'spec'
+require 'spec/rake/spectask'
+task :spec => 'spec:all'
+namespace(:spec) do
+  Spec::Rake::SpecTask.new(:all) do |t|
+    t.spec_opts ||= []
+    t.spec_opts << "-rubygems"
+    t.spec_opts << "--options" << "spec/spec.opts"
+    t.spec_files = FileList['spec/**/*_spec.rb']
+  end
+
+end

data/application_spec/app/runner.rb

@@ -0,0 +1,3 @@
+with 'this is my message' do
+  say 'well, that was fun'
+end

data/application_spec/bin/runner

@@ -0,0 +1,18 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+begin
+  require 'messed'
+rescue LoadError
+  if ENV['MESSED_HOME']
+    require File.join(ENV['MESSED_HOME'], 'lib', 'messed')
+  else  
+    raise("no messed!")
+  end
+end
+
+require 'thor'
+
+$root = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+Messed::Tasks::Runner.start

data/application_spec/bin/status

@@ -0,0 +1,36 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+begin
+  require 'messed'
+rescue LoadError
+  if ENV['MESSED_HOME']
+    require File.join(ENV['MESSED_HOME'], 'lib', 'messed')
+  else  
+    raise("no messed!")
+  end
+end
+
+require 'thor'
+
+class IncomingRunnerTask < Thor
+
+  method_options :detach => false
+  method_options :environment => "development"
+  desc "start [NAME]", "start an incoming instance"
+  def start(name = nil)
+    application = Messed::Booter.new(File.expand_path(File.join(File.dirname(__FILE__), '..')), options.environment)
+    incoming = if name.nil? and application.incoming_map.size == 1
+      application.incoming_map.values.first
+    elsif application.incoming_map.key?(name)
+      application.incoming_map[name]
+    else
+      raise(name ? "unable to find incoming with name #{name}" : "You have no incoming setup.")
+    end
+    
+    IncomingRunner.new(incoming)
+  end
+  
+end
+
+IncomingRunnerTask.start

data/application_spec/bin/web

@@ -0,0 +1,29 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+begin
+  require 'messed'
+rescue LoadError
+  if ENV['MESSED_HOME']
+    require File.join(ENV['MESSED_HOME'], 'lib', 'messed')
+  else  
+    raise("no messed!")
+  end
+end
+
+require 'thor'
+
+class WebTask < Thor
+
+  method_options :detach => false
+  method_options :environment => "development"
+  desc "start [NAME]", "start an incoming instance"
+  def start(name = nil)
+    
+    
+    
+  end
+  
+end
+
+IncomingRunnerTask.start

data/application_spec/config/environment.rb

@@ -0,0 +1,8 @@
+queues.incoming.host = '127.0.0.1'
+queues.incoming.port = 11300
+queues.incoming.tube = 'incoming-tube'
+
+queues.outgoing.host = '127.0.0.1'
+queues.outgoing.port = 11300
+queues.outgoing.tube = 'outgoing-tube'
+

data/application_spec/log/development.log

@@ -0,0 +1,6 @@
+Processing `this is my message'
+Processing `this is my message'
+Processing `this is my message'
+Processing `this is my message'
+Processing `this is my message'
+Processing `this is my message'

data/application_spec/spec/application_spec.rb

@@ -0,0 +1,12 @@
+require 'spec/spec_helper'
+
+describe "test" do
+  
+  include MessedSpecHelper
+  
+  it "should have a test" do
+    process('this is my message')
+    outgoing_messages.size.should == 1
+    outgoing_messages.first.body.should == "well, that was fun"
+  end
+end

data/application_spec/spec/spec.opts

@@ -0,0 +1,7 @@
+--colour
+--format
+specdoc
+--loadby
+mtime
+--reverse
+--backtrace

data/application_spec/spec/spec_helper.rb

@@ -0,0 +1,42 @@
+require 'rubygems'
+begin
+  require 'messed'
+rescue LoadError
+  if ENV['MESSED_HOME']
+    require File.join(ENV['MESSED_HOME'], 'lib', 'messed')
+  else  
+    raise("no messed!")
+  end
+end
+
+class MessedSpecHolder
+  
+  attr_accessor :booter, :outgoing_messages
+  
+  def initialize
+    @booter = Messed::Booter.new(File.join(File.dirname(__FILE__), '..'))
+  end
+  
+  def application
+    @booter.application
+  end
+  
+  def process(message)
+    @outgoing_messages = application.process(application.message_class.new(message))
+  end
+  
+end
+
+module MessedSpecHelper
+
+  Holder = MessedSpecHolder.new
+
+  def process(message)
+    Holder.process(message)
+  end
+
+  def outgoing_messages
+    Holder.outgoing_messages
+  end
+  
+end

data/bin/messed

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby -rubygems
+# Messed generation script
+require File.dirname(__FILE__) + '/../lib/messed'
+
+if ARGV[0]
+  Messed::Tasks::Generation.new(ARGV[0])
+else
+  $stderr.puts "Please specify a name for your application"
+end

data/lib/messed/booter.rb

@@ -0,0 +1,114 @@
+require 'fileutils'
+
+class Messed
+  class Booter
+    
+    include Logger::LoggingModule
+    
+    attr_reader :root_directory, :environment, :application, :interface_map, :configuration, :pid
+    
+    def initialize(root_directory, options = {}, &block)
+      if block
+        EMRunner.new(:detach => options[:detach], :supress_banner => options[:supress_banner]) {
+          setup_booter(root_directory, options)
+          record_pid(Process.pid)
+          yield self
+        }
+      else
+        setup_booter(root_directory, options)
+      end
+    end
+    
+    def setup_booter(root_directory, options)
+      $LOAD_PATH << File.expand_path(root_directory)
+      
+      @root_directory = root_directory
+      @environment = options[:environment] || 'development'
+
+      load_configuration
+      prepare_root
+      setup_logger
+      setup_queues
+      setup_interfaces
+      setup_application
+    end
+
+    def record_pid(pid)
+      @pid = pid
+    end
+    
+    def expand_pid_file(pid_file)
+      File.expand_path(pid_file, root_directory)
+    end
+    
+    def write_pid_file(pid_file)
+      File.open(expand_pid_file(pid_file), 'w') {|f| f << pid} if pid_file
+    end
+
+    def read_pid_file(pid_file)
+      Integer(File.read(expand_pid_file(pid_file)))
+    rescue ArgumentError
+      nil
+    end
+
+    def prepare_root
+      FileUtils.mkdir_p(File.join(root_directory, 'log'))
+      FileUtils.mkdir_p(File.join(root_directory, 'tmp', 'pid'))
+    end
+
+    def load_configuration
+      @configuration = Configuration.load_from_directory(@environment, File.expand_path(File.join(root_directory, 'config')))
+    end
+
+    def setup_queues
+      @incoming_queue = create_incoming_queue
+      @outgoing_queue = create_outgoing_queue
+    end
+    
+    def setup_application
+      @application = Messed.new
+      @application.booter = self
+      @application.incoming = create_incoming_queue
+      @application.outgoing = create_outgoing_queue
+      @application.instance_eval(File.read(runner_file), runner_file)
+    end
+
+    def setup_logger
+      Messed::Logger.instance.setup_logger(configuration.logger || ::Logger.new(File.open(File.join(root_directory, 'log', "#{environment}.log"), File::WRONLY | File::APPEND | File::CREAT)), configuration.log_level || :debug)
+    end
+    
+    def self.possible_interfaces(path)
+      booter = new(path)
+      booter.configuration.interfaces.names
+    end
+    
+    def runner_file
+      File.join(root_directory, 'app/runner.rb')
+    end
+    
+    def environmental_configuration_file
+      File.join(root_directory, "config/environments/#{environment}.rb")
+    end
+    
+    def setup_interfaces
+      @interface_map = {}
+      configuration.interfaces.each do |name, conf|
+        logger.info "Setting up interface: #{name.inspect}"
+        @interface_map[name] = Interface.interface_from_configuration(self, name, conf)
+      end
+    end
+    
+    def interface_for(name)
+      interface_map[name]
+    end
+    
+    def create_incoming_queue
+      Messed::Queue::Beanstalk.new(configuration.queues.incoming.tube, configuration.queues.incoming.host, configuration.queues.incoming.port)
+    end
+    
+    def create_outgoing_queue
+      Messed::Queue::Beanstalk.new(configuration.queues.outgoing.tube, configuration.queues.outgoing.host, configuration.queues.outgoing.port)
+    end
+    
+  end
+end

data/lib/messed/configuration.rb

@@ -0,0 +1,94 @@
+class Messed
+  class Configuration
+    
+    module ConfigHelper
+      
+      def with(&block)
+        instance_eval(&block)
+      end
+      
+    end
+    
+    def self.load_from_directory(environment, dir)
+      environments = []
+      Dir[File.join(dir, '*')].each do |file|
+        environments << file if File.directory?(file)
+      end
+
+      instance = new(environments, environment)
+
+      instance.instance_eval(File.read(File.join(dir, 'environment.rb')), File.join(dir, 'environment.rb'), 1)
+      instance.instance_eval(File.read(File.join(dir, 'environments', "#{environment}.rb")), File.join(dir, 'environments', "#{environment}.rb"), 1)
+
+      instance
+    end
+    
+    class Interfaces
+      include ConfigHelper
+      
+      def initialize
+        @interfaces = {}
+      end
+      
+      def each(&block)
+        @interfaces.each(&block)
+      end
+      
+      def names
+        @interfaces.keys
+      end
+      
+      def method_missing(method, *args, &block)
+        @interfaces[method] ||= IndividualInterface.new
+      end
+      
+      class IndividualInterface
+
+        include ConfigHelper
+
+        attr_accessor :adapter, :options, :status_port, :status_address, :pid_file
+        
+        def initialize
+          @options = {}
+        end
+        
+      end
+      
+    end
+    
+    class Queues
+      include ConfigHelper
+      attr_reader :incoming, :outgoing
+      
+      def initialize
+        @incoming = IndivialQueue.new
+        @outgoing = IndivialQueue.new
+      end
+      
+      class IndivialQueue
+        include ConfigHelper
+        attr_accessor :host, :port, :tube
+      end
+      
+    end
+
+    class Application
+      include ConfigHelper
+      attr_accessor :status_port, :status_address, :pid_file
+    end
+
+    include ConfigHelper
+    
+    attr_reader :queues, :interfaces, :application, :environment, :environments
+    attr_accessor :logger, :log_level
+    
+    def initialize(environments, environment)
+      @environments, @environment = environments, environment
+      @queues = Queues.new
+      @interfaces = Interfaces.new
+      @application = Application.new
+    end
+
+    
+  end
+end

data/lib/messed/controller/helper.rb

@@ -0,0 +1,8 @@
+class Messed
+  class Controller
+    module Helper
+      attr_accessor :message, :params, :session
+    end
+  end
+end
+    

data/lib/messed/controller/processing.rb

@@ -0,0 +1,22 @@
+class Messed
+  class Controller
+  
+    module Processing
+      def self.included(target)
+      
+        target.send(:class_variable_set, :@@after, []) unless target.send(:class_variable_defined?, :@@after)
+        target.class_eval "
+
+          def self.after_processing(t)
+            @@after << t
+          end
+
+          def reset_processing!
+            @@after.each {|a| send(a)}
+          end
+        "
+      
+      end
+    end
+  end
+end

data/lib/messed/controller/respond.rb

@@ -0,0 +1,48 @@
+class Messed
+  class Controller
+    module Respond
+    
+      def self.included(c)
+        c.instance_eval "
+          after_processing :clear_responses
+        "
+      end
+    
+      def responses
+        @response ||= []
+      end
+    
+      def clear_responses
+        responses.clear
+      end
+    
+      def say(response)
+        set_response(response)
+      end
+
+      def reply(response, options = {})
+        options[:to] ||= message.from
+        options[:from] ||= message.to
+        options[:in_reply_to] ||= message
+        set_response(response, options)
+      end
+
+      def whisper(response, options = {})
+        options[:private] = true
+        reply(response, options)
+      end
+    
+      def set_response(response, options = nil)
+        message = message_class.new
+        message.body = response.is_a?(Message) ? response.body : response
+        if options
+          options.each do |key, value|
+            message.send(:"#{key}=", value)
+          end
+        end
+        self.responses << message
+      end
+    
+    end
+  end
+end

data/lib/messed/controller.rb

@@ -0,0 +1,17 @@
+class Messed
+  class Controller
+
+    autoload :Processing,  File.join('messed', 'controller', 'processing')
+    autoload :Respond,     File.join('messed', 'controller', 'respond')
+    autoload :Helper,      File.join('messed', 'controller', 'helper')
+
+    def self.inherited(subclass)
+      subclass.instance_eval "
+        include Messed::Controller::Helper
+        include Messed::Controller::Processing
+        include Messed::Controller::Respond
+      "
+    end
+    
+  end
+end

data/lib/messed/em_runner.rb

@@ -0,0 +1,50 @@
+class Messed
+  class EMRunner
+    
+    include Logger::LoggingModule
+    
+    class StatusHandler < EventMachine::Connection
+      
+      attr_accessor :interface
+      
+      Terminator = "\r\n"
+      TerminatorRegex = /\r\n/
+      Error = "ERROR\r\n" 
+      
+      def receive_data(data)
+        ss = StringScanner.new(data)
+        while part = ss.scan_until(TerminatorRegex)
+          if part == 'status'
+            send_data(interface.status)
+            send_data(Terminator)
+          else
+            send_data(Error)
+          end
+        end
+      end
+    end
+
+    def initialize(options, &block)
+      logger.info "Starting..." unless options[:supress_banner]
+      if options[:detach]
+        pid = EM.fork_reactor do
+          trap("INT") { EM.stop_reactor_loop }
+          EM.run do
+            EM.next_tick(&block)
+          end
+        end
+        Process.detach(pid)
+        exit(0)
+      else
+        EM.run do
+          EM.next_tick(&block)
+        end
+      end
+    end
+
+    def quit
+      EM.stop; logger.info "\nStoping #{interface.name.to_s}"; exit(0)
+    end
+    
+  end
+end

data/lib/messed/interface/adapter/sms.rb

@@ -0,0 +1,4 @@
+class Messed
+  class Interface
+    class Adapter
+      class SMS < Adapter