adammck-rubysms 0.8.1

data/lib/rubysms/errors.rb

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+# vim: noet
+
+
+module SMS
+	class InvalidBackend < Exception
+	end
+	
+	class CancelIncoming < StandardError
+	end
+	
+	class CancelOutgoing < StandardError
+	end
+	
+	class Respond < Interrupt
+	end
+end

data/lib/rubysms/logger.rb

@@ -0,0 +1,69 @@
+#!/usr/bin/env ruby
+# vim: noet
+
+module SMS
+	class Logger
+		def initialize(stream=$stdout)
+			@stream = stream
+		end
+		
+		def event(str, type=:info)
+			
+			# arrays or strings are fine. quack!
+			str = str.join("\n") if str.respond_to?(:join)
+			
+			# each item in the log is prefixed by a four-char
+			# coloured prefix block, to help scanning by eye
+			prefix_text = LogPrefix[type] || type.to_s
+			prefix = colored(prefix_text, type)
+			
+			# the first line of the message is indented by
+			# the prefix, so indent subsequent lines by an
+			# equal amount of space, to keep them lined up
+			indent = colored((" " * prefix_text.length), type) + " "
+			@stream.puts prefix + " " + str.to_s.gsub("\n", "\n#{indent}")
+			
+			# flush immediately, to prevent
+			# the log being backend up
+			@stream.flush
+		end
+		
+		def event_with_time(str, *rest)
+			event("#{time_log(Time.now)} #{str}", *rest)
+		end
+
+		private
+
+		# Returns a short timestamp suitable
+		# for embedding in the screen log.
+		def time_log(dt=nil)
+			dt = DateTime.now unless dt
+			dt.strftime("%I:%M%p")
+		end
+		
+		def colored(str, color)
+			
+			# resolve named colors
+			# to their ANSI color
+			color = LogColors[color]\
+				if color.is_a? Symbol
+			
+			# return the ugly ANSI string
+			"\e[#{color};37;1m#{str}\e[0m"
+		end
+		
+		LogColors = {
+			:init => 46,
+			:info => 40,
+			:warn => 41,
+			:err  => 41,
+			:in   => 45,
+			:out  => 45 }
+	
+		LogPrefix = {
+			:info => "    ",
+			:err  => "FAIL",
+			:in   => " << ",
+			:out  => " >> " }
+	end
+end

data/lib/rubysms/message/incoming.rb

@@ -0,0 +1,58 @@
+#!/usr/bin/env ruby
+# vim: noet
+
+
+module SMS
+	class Incoming
+		attr_reader :sent, :received, :text
+		attr_reader :backend, :sender, :responses
+		
+		def initialize(backend, sender, sent, text)
+			
+			# move all arguments into read-only
+			# attributes. ugly, but Struct only
+			# supports read/write attrs
+			@backend = backend
+			@sent = sent
+			@text = text
+			
+			# Sets @sender, transforming _sender_ into an SMS::Person if
+			# it isn't already (to enable persistance between :Outgoing
+			# and/or SMS::Incoming objects)
+			@sender = sender.is_a?(SMS::Person) ? sender : SMS::Person.fetch(backend, sender)
+			
+			# assume that the message was
+			# received right now, since we
+			# don't have an incoming buffer
+			@received = Time.now
+			
+			# initialize a place for responses
+			# to this message to live, to be
+			# extracted (for logging?) later
+			@responses = []
+		end
+		
+		# Creates an SMS::Outgoing object, adds it to _@responses_, and links
+		# it back to this SMS::Incoming object via Outgoing#in_response_to.
+		# IMPORTANT: This method doesn't actually SEND the message, it just
+		# creates it - use Incoming#respond to create an send in one call.
+		# This is most useful when you want to quickly create a response,
+		# modify it a bit, and send it.
+		def create_response(response_text)
+			og = SMS::Outgoing.new(backend, sender, response_text)
+			og.in_response_to = self
+			@responses.push(og)
+			og
+		end
+		
+		# Same as Incoming#respond, but also sends the message.
+		def respond(response_text)
+			create_response(response_text).send!
+		end
+		
+		# Returns the phone number of the sender of this message.
+		def phone_number
+			sender.phone_number
+		end
+	end
+end

data/lib/rubysms/message/outgoing.rb

@@ -0,0 +1,40 @@
+#!/usr/bin/env ruby
+# vim: noet
+
+
+module SMS
+	class Outgoing
+		attr_accessor :text, :in_response_to
+		attr_reader :backend, :recipient, :sent
+		
+		def initialize(backend, recipient=nil, text=nil)
+			
+			# move all arguments into instance
+			# vars, to be accessed by accessors
+			@backend = backend
+			@text = text
+			
+			# Sets @recipient, transforming _recipient_ into an SMS::Person if
+			# it isn't already (to enable persistance between :Outgoing and/or
+			# SMS::Incoming objects)
+			@recipient = recipient.is_a?(SMS::Person) ? recipient : SMS::Person.fetch(backend, recipient)
+		end
+		
+		# Sends the message via _@backend_ NOW, and
+		# prevents any further modifications to self,
+		# to avoid the object misrepresenting reality.
+		def send!
+			backend.send_sms(self)
+			@sent = Time.now
+			
+			# once sent, allow no
+			# more modifications
+			freeze
+		end
+		
+		# Returns the phone number of the recipient of this message.
+		def phone_number
+			recipient.phone_number
+		end
+	end
+end

data/lib/rubysms/person.rb

@@ -0,0 +1,47 @@
+#!/usr/bin/env ruby
+# vim: noet
+
+module SMS
+	class Person < Hash
+		@@people = {}
+		
+		def self.fetch(backend, key)
+			
+			# if a people hash doesn't exist for
+			# this backend yet, create one now
+			unless @@people.has_key?(backend)
+				@@people[backend] = {}
+			end
+			
+			# if a person object doesn't already exist for this key,
+			# create one (to be fetched again next time around)
+			unless @@people[backend].has_key?(key)
+				p = SMS::Person.new(backend, key)
+				@@people[backend][key] = p
+			end
+			
+			# return the persistant person,
+			# which may or may not be new
+			@@people[backend][key]
+		end
+		
+		
+		attr_reader :backend, :key
+		
+		def initialize(backend, key)
+			@backend = backend
+			@key = key
+		end
+		
+		# Return this person is a vaguely useful
+		# way that doesn't look too out of place.
+		def to_s
+			"#<SMS::Person backend=#{backend.label}, key=#{key}>"
+		end
+		
+		# wat
+		def phone_number
+			key
+		end
+	end
+end

data/lib/rubysms/router.rb

@@ -0,0 +1,198 @@
+#!/usr/bin/env ruby
+# vim: noet
+
+module SMS
+	class Router
+		attr_reader :apps, :backends
+		
+		
+		def initialize
+			@log = Logger.new(STDOUT)
+			@backends = []
+			@apps = []
+		end
+		
+		
+		# proxy methods to pass events
+		# to the logger with the pretty
+		
+		def log(*args)
+			@log.event(*args)
+		end
+		
+		def log_with_time(*args)
+			@log.event_with_time(*args)
+		end
+		
+		def log_exception(error, prefix_message=nil)
+			msgs = [error.class, error.message]
+			
+			# if a prefix was provided (to give a litle
+			# more info on what went wrong), prepend it
+			# to the output with a blank line
+			unless prefix_message.nil?
+				msg.shift prefix_message, ""
+			end
+			
+			# add each line until the current frame is within
+			# rubysms (the remainder will just be from gems)
+			catch(:done) do
+				error.backtrace.each do |line|
+					if line =~ /^#{SMS::Root}/
+						throw :done
+					end
+					
+					# still within the application,
+					# so add the frame to the log
+					msgs.push("  " + line)
+				end
+			end
+			
+			@log.event msgs, :warn
+		end
+		
+		
+		# Starts listening for incoming messages
+		# on all backends, and never returns.
+		def serve_forever
+			
+			# (attempt to) start up each
+			# backend in a separate thread
+			@backends.each do |b|
+				Thread.new do
+					b.start
+				end
+			end
+			
+			# applications don't need their own
+			# thread (they're notified in serial),
+			# but do have a #start method
+			@apps.each { |a| a.start }
+
+			# catch interrupts and display a nice message (rather than
+			# a backtrace). to avoid seeing control characters (^C) in
+			# the output, disable the "echoctl" option in your terminal
+			# (i added "stty -echoctl" to my .bashrc)
+			trap("INT") do
+				log "Shutting down", :init
+			
+				# fire the "stop" method of
+				# each application and backend
+				# before terminating the process
+				(@backends + @apps).each do |inst|
+					inst.stop
+				end
+			
+				exit
+			end
+		
+			# block until ctrl+c
+			while true do
+				sleep 5
+			end
+		end
+		
+		# Accepts an SMS::Backend::Base or SMS::App instance,
+		# which is stored until _serve_forever_ is called.
+		# DEPRECATED because it's confusing and magical.
+		def add(something)
+			log "Router#add is deprecated; use " +\
+			    "#add_backend and #add_app", :warn
+			
+			if something.is_a? SMS::Backend::Base
+				@backends.push(something)
+			
+			elsif something.is_a? SMS::App
+				@apps.push(something)
+			
+			else
+				raise RuntimeError,
+					"Router#add doesn't know what " +\
+					"to do with a #{something.klass}"
+			end
+			
+			# store a reference back to this router in
+			# the app or backend, so it can talk back
+			something.router = self
+		end
+		
+		# Adds an SMS application (which is usually an instance of a subclass
+		# of SMS::App, but anything's fine, so long as it quacks the right way)
+		# to this router, which will be started once _serve_forever_ is called.
+		def add_app(app)
+			@apps.push(app)
+			app.router = self
+		end
+		
+		# Adds an SMS backend (which MUST be is_a?(SMS::Backend::Base), for now),
+		# or a symbol representing a loadable SMS backend, which is passed on to
+		# SMS::Backend.create (along with *args) to be required and initialized.
+		# This only really works with built-in backends, for now, but is useful
+		# for initializing those:
+		#
+		#   # start serving with a single
+		#   # http backend on port 9000
+		#   router = SMS::Router.new
+		#   router.add_backend(:HTTP, 9000)
+		#   router.serve_forever
+		#
+		#   # start serving on two gsm
+		#   # modems with pin numbers
+		#   router = SMS::Router.new
+		#   router.add_backend(:GSM, "/dev/ttyS0", 1234)
+		#   router.add_backend(:GSM, "/dev/ttyS1", 5678)
+		#   router.serve_forever
+		def add_backend(backend, *args)
+			
+			# if a backend object was given, add it to this router
+			# TODO: this modifies the argument just slightly. would
+			# it be better to duplicate the object first?
+			if backend.is_a?(SMS::Backend::Base)
+				@backends.push(backend)
+				backend.router = self
+			
+			# if it's a named backend, spawn it (along
+			# with the optional arguments) and recurse
+			elsif backend.is_a?(Symbol)
+				add_backend SMS::Backend.create(backend, *args)
+			end
+		end
+		
+		# Relays a given incoming message from a
+		# specific backend to all applications.
+		def incoming(msg)
+			log_with_time "[#{msg.backend.label}] #{msg.sender.key}: #{msg.text} (#{msg.text.length})", :in
+			
+			# notify each application of the message.
+			# they may or may not respond to it
+			@apps.each do |app|
+				begin
+					app.incoming msg
+				
+				# something went boom in the app
+				# log it, and continue with the next
+				rescue StandardError => err
+					log_exception(err)
+					
+				#	if msg.responses.empty?
+				#		msg.respond("Sorry, there was an error while processing your message.")
+				#	end
+				end
+			end
+		end
+		
+		# Notifies each application of an outgoing message, and
+		# logs it. Should be called by all backends prior to sending.
+		def outgoing(msg)
+			log_with_time "[#{msg.backend.label}] #{msg.recipient.key}: #{msg.text} (#{msg.text.length})", :out
+			log("Outgoing message exceeds 140 characters", :warn) if msg.text.length > 140
+			cancelled = false
+			
+			# notify each app of the outgoing sms
+			# note that the sending can still fail
+			@apps.each do |app|
+				app.outgoing msg
+			end
+		end
+	end
+end

data/lib/rubysms/thing.rb

@@ -0,0 +1,38 @@
+#!/usr/bin/env ruby
+# vim: noet
+
+module SMS
+	class Thing
+		attr_accessor :router, :label
+		
+		
+		# stubs to avoid respond_to? or
+		# NoMethodError on subclasses
+		def incoming(*args); end
+		def outgoing(*args); end
+		def start(*args); end
+		def stop(*args); end
+		
+		def label
+			@label or self.class.to_s.scan(/[a-z]+\Z/i).first
+		end
+		
+		
+		protected
+		
+		# proxy method(s) back to the router, so
+		# apps and backends can log things merrily
+		
+		def log(*args)
+			router.log(*args)
+		end
+		
+		def log_with_time(*args)
+			router.log_with_time(*args)
+		end
+		
+		def log_exception(*args)
+			router.log_exception(*args)
+		end
+	end
+end