joggle 0.1.0

data/lib/joggle/cli/option-parser.rb

@@ -0,0 +1,139 @@
+require 'optparse'
+require 'joggle/version'
+require 'joggle/config-parser'
+require 'joggle/cli/option-parser'
+
+module Joggle
+  module CLI
+    # 
+    # Option parser for Joggle command-line interface.
+    # 
+    class OptionParser
+      # 
+      # Default configuration.
+      # 
+      DEFAULTS = {
+        # pull default jabber username and password from environment
+        'jabber.user' => ENV['JOGGLE_USERNAME'],
+        'jabber.pass' => ENV['JOGGLE_PASSWORD'],
+      }
+
+      # 
+      # Create and run a new command-line option parser.
+      # 
+      def self.run(app, args)
+        new(app).run(args)
+      end
+
+      # 
+      # Create new command-line option parser.
+      # 
+      def initialize(app)
+        @app = app
+      end
+
+      # 
+      # Run command-line option parser.
+      # 
+      def run(args)
+        ret = DEFAULTS.merge({})
+
+        # create option parser
+        o = ::OptionParser.new do |o|
+          o.banner = "Usage: #@app [options]"
+          o.separator " "
+
+          # add command-line options
+          o.separator "Options:"
+
+          o.on('-A', '--allow USER', 'Allow Jabber subscription from USER.') do |v|
+            add_allowed(ret, v)
+          end
+
+          o.on('-c', '--config FILE', 'Use configuration file FILE.') do |v|
+            Joggle::ConfigParser.run(v) do |key, val|
+              if key == 'engine.allow'
+                add_allowed(ret, val)
+              elsif key == 'engine.update.range'
+                add_update_range(ret, val)
+              else
+                ret[key] = val
+              end
+            end
+          end
+
+          o.on('-D', '--daemon', 'Run as daemon (in background).') do |v|
+            ret['cli.daemon'] = true
+          end
+
+          o.on('--foreground', 'Run in foreground (the default).') do |v|
+            ret['cli.daemon'] = false
+          end
+
+          o.on('-L', '--log-level LEVEL', 'Set log level to LEVEL.') do |v|
+            ret['runner.log.level'] = v
+          end
+
+          o.on('-l', '--log FILE', 'Log to FILE.') do |v|
+            ret['runner.log.path'] = v
+          end
+
+          o.on('-p', '--password PASS', 'Jabber password (INSECURE!).') do |v|
+            ret['jabber.pass'] = v
+          end
+
+          o.on('-s', '--store FILE', 'Use FILE as backing store.') do |v|
+            ret['runner.store.path'] = v
+          end
+
+          o.on('-u', '--username USER', 'Jabber username.') do |v|
+            ret['jabber.user'] = v
+          end
+
+          o.separator ' '
+
+          o.on_tail('-v', '--version', 'Print version string.') do
+            puts "Joggle %s, by %s" % [
+              Joggle::VERSION,
+              'Paul Duncan <pabs@pablotron.org>',
+            ]
+            exit
+          end
+
+          o.on_tail('-h', '--help', 'Print help information.') do
+            puts o
+            exit
+          end
+        end
+
+        # parse arguments
+        o.parse(args)
+
+        # return results
+        ret
+      end
+
+      private 
+
+      #
+      # Add an allowed user.
+      #
+      def add_allowed(ret, val)
+        return unless val && val =~ /\S/
+
+        ret['engine.allow'] ||= []
+        ret['engine.allow'].concat(val.strip.downcase.split(/\s*,\s*/))
+      end
+
+      def add_update_range(ret, val)
+        return unless val && val =~ /\S/
+
+        if md = val.match(/(\d+)\s*-\s*(\d+)\s+(\d+)/)
+          key, mins = "#{md[1]}-#{md[2]}", md[3].to_i
+          ret['engine.update.range'] ||= {}
+          ret['engine.update.range'][key] = mins
+        end
+      end
+    end
+  end
+end

data/lib/joggle/cli/runner.rb

@@ -0,0 +1,47 @@
+require 'joggle/runner/pstore'
+require 'joggle/cli/option-parser'
+
+module Joggle
+  module CLI
+    #
+    # Basic command-line interface for Joggle.
+    #
+    class Runner
+      #
+      # Create and run a CLI object.
+      #
+      def self.run(app, args)
+        new(app, args).run
+      end
+
+      #
+      # Create CLI object.
+      #
+      def initialize(app, args)
+        @opt = OptionParser.run(app, args)
+      end
+
+      #
+      # Run command-line interface.
+      #
+      def run
+        if @opt['cli.daemon']
+          pid = Process.fork { 
+            Joggle::Runner::PStore.run(@opt)
+            exit 0;
+          }
+
+          # detach from background process
+          Process.detach(pid)
+
+          # print process id and exit
+          $stderr.puts "Detached from pid #{pid}"
+        else
+          Joggle::Runner::PStore.run(@opt)
+        end
+
+        exit 0;
+      end
+    end
+  end
+end

data/lib/joggle/commands.rb

@@ -0,0 +1,163 @@
+module Joggle
+  #
+  # Mixin to handle commands.
+  #
+  module Commands
+    #
+    # Handle .register command.
+    #
+    def do_register(who, arg)
+      # see if user is registered
+      if user = @tweeter.registered?(who)
+        # user is registered, return error
+        msg = "Already registered as #{user}"
+      else 
+        # user isn't registered, so add them
+         
+        # get twitter username and password from argument
+        user, pass = arg.split(/\s+/, 2)
+
+        # register user
+        begin 
+          @tweeter.register(who, user, pass)
+          msg = "Registered as #{user}"
+        rescue Exception => err
+          msg = "Couldn't register: #{err}"
+        end
+      end
+
+      # reply to request
+      reply(who, msg)
+    end
+
+    #
+    # Handle .unregister command.
+    #
+    def do_unregister(who, arg)
+      # see if user is registered
+      if @tweeter.registered?(who)
+        # user is registerd, so unregister them
+         
+        begin 
+          # unregister user
+          @tweeter.unregister(who)
+
+          # send success
+          msg = "Unregistered."
+        rescue Exception => err
+          msg = "Couldn't unregister: #{err}"
+        end
+      else 
+        # user isn't registered, send error
+        msg = "Not registered."
+      end
+
+      # reply to request
+      reply(who, msg)
+    end
+
+    #
+    # Handle .list command.
+    #
+    def do_list(who, arg)
+      # see if user is registered
+      if @tweeter.registered?(who)
+        # user is registerd, so unregister them
+         
+        begin 
+          msgs = []
+
+          # build list
+          @tweeter.list(who) do |id, time, from, msg|
+            msgs << make_response(id, time, from, msg)
+          end
+
+          # build response
+          if msgs.size > 0
+            msg = msgs.join("\n")
+          else
+            msg = 'No tweets.'
+          end
+        rescue Exception => err
+          msg = "Couldn't list tweets: #{err}"
+        end
+      else 
+        # user isn't registered, send error
+        msg = "Not registered."
+      end
+
+      # reply to request
+      reply(who, msg)
+    end
+
+    #
+    # String constant for .help command.
+    #
+    HELP = [
+      "Joggle Help:",
+      "Available commands:",
+      "  .help                   - Display this help screen.",
+      "  .register <user> <pass> - Register Twitter username and password.",
+      "  .unregister             - Forget Twitter username and password.",
+      # TODO: "  .force <msg>            - Force tweet.",
+      # TODO: "  .list                   - List recent tweets.",
+      "Any other message with two words or more is sent as a tweet.  See the Joggle home page at http://pablotron.org/software/joggle/ for additional information",
+    ].join("\n")
+
+    #
+    # Handle .help command.
+    #
+    def do_help(who, arg)
+      reply(who, HELP)
+    end
+
+    EGGS = [
+      # movie quotes
+      "This is what happens, Larry!",
+      "Got a package, people!",
+      "Billy, do you like wrestling?",
+      "NO AND DEN!",
+      "I'm the dude playing the dude disguised as another dude.",
+      "Hey, want to hear the most annoying sound in the world?",
+      "Bueller?",
+      "Inconcievable!",
+
+      # non-movie quotes
+      "You are in a maze of twisty compiler features, all different.",
+      "You can tune a filesystem, but you can't tuna fish.",
+      "Never attribute to malice that which can adequately explained by stupidity.",
+      "The first thing to do when you find yourself in a hole is to stop digging.",
+      "I once knew a man who had a dog with only three legs, and yet that man could play the banjo like anything.",
+      "The needs of the many outweigh the needs of the guy who can't run fast.",
+      "It may look like I'm doing nothing, but I'm actively waiting for my problems to go away.",
+      "Nobody ever went broke underestimating the intelligence of the American people.",
+      "There are only two things wrong with C++: The initial concept and the implementation.",
+      "There are only two kinds of people, those who finish what they start, and so on.",
+
+      # exclamations
+      "I'LL SAY!!!",
+      "AND HOW!!!",
+      "Cha-ching!",
+      "Crikey!",
+      "Nope.",
+      "Sweet!",
+      "Blimey!",
+
+      # emoticons
+      ":-D",
+      "^_^",
+      ":(",
+      ":-)",
+      ":')-|-<",
+
+      # misc
+      "http://pablotron.org/offended",
+      "<INSERT WITTY REMARK HERE>",
+      "0xBEEFCAFE",
+    ]
+
+    def do_easteregg(who, arg)
+      reply(who, EGGS[rand(EGGS.size)])
+    end
+  end
+end

data/lib/joggle/config-parser.rb

@@ -0,0 +1,37 @@
+module Joggle
+  #
+  # Simple configuration file parser.
+  #
+  class ConfigParser
+    #
+    # Parse configuration file and pass each directive to the
+    # specified block.
+    #
+    def self.run(path, &block)
+      new(path).run(&block)
+    end
+
+    #
+    # Create a new config file parser.
+    #
+    def initialize(path)
+      @path = path
+    end
+
+    #
+    # Parse configuration file and pass each directive to the specified
+    # block.
+    #
+    def run(&block)
+      File.readlines(@path).each do |line|
+        next if line =~ /\s*#/ || line !~ /\S/
+        line = line.strip
+        key, val = line.split(/\s+/, 2)
+
+        if key && key.size > 0
+          block.call(key, val)
+        end
+      end
+    end
+  end
+end

data/lib/joggle/engine.rb

@@ -0,0 +1,276 @@
+require 'joggle/pablotron/observable'
+require 'joggle/commands'
+
+module Joggle
+  #
+  # Joggle engine object.  This is where the magic happens.
+  #
+  class Engine
+    include Joggle::Pablotron::Observable
+    include Commands
+
+    DEFAULTS = {
+      # output time format
+      'engine.time_format'              => '%H:%M',
+
+      # enable sanity checks
+      'engine.message_sanity_checks'    => true,
+
+      # update every 60 minutes by default
+      'engine.update.default'           => 60,
+
+      # time ranges for updates
+      'engine.update.range'             => {
+        # from 8am until 3pm, update every 10 minutes
+        '8-15'    => 10,
+
+        # from 3pm until 10pm, update every 5 minutes
+        '15-22'   => 5,
+
+        # from 10pm until midnight, update every 10 minutes
+        '22-24'   => 10,
+
+        # from midnight until 2am, update every 20 minutes
+        '0-2'     => 20,
+      },
+    }
+
+    #
+    # Create a new Joggle engine object.
+    #
+    def initialize(client, tweeter, opt = nil)
+      @opt = DEFAULTS.merge(opt || {})
+
+      @client = client
+      @client.on(self)
+
+      @tweeter = tweeter
+    end
+
+    #
+    # Run forever.
+    #
+    def run
+      loop {
+        # check for updates (if we need to)
+        if need_update?
+          update
+        end
+
+        # fire idle method
+        fire('engine_idle')
+
+        # sleep for thirty seconds
+        sleep 30
+      }
+    end
+
+    #
+    # Reply to a user with the given message.
+    #
+    def reply(who, msg)
+      begin
+        if fire('engine_before_reply', who, msg)
+          @client.deliver(who, msg)
+          fire('engine_reply', who, msg)
+        else
+          fire('engine_reply_stopped', who, msg, err)
+        end
+      rescue Exception => err
+        fire('engine_reply_error', who, msg, err)
+      end
+    end
+
+    ####################
+    # client listeners #
+    ####################
+
+    COMMAND_REGEX = /^\s*\.(\w+)\s*(\S.*|)\s*$/
+
+    #
+    # Jabber message listener callback.
+    #
+    def on_jabber_client_message(client, msg)
+      # get the message source
+      who = msg.from.to_s
+
+      # only listen to allowed users
+      if allowed?(who)
+        if md = msg.body.match(COMMAND_REGEX)
+          cmd = md[1].downcase
+          handle_command(who, cmd, md[2])
+        else
+          handle_message(who, msg.body)
+        end
+      else
+        fire('engine_ignored_message', who, msg)
+      end
+    end
+
+    #
+    # Jabber subscription listener callback.
+    #
+    def on_before_jabber_client_accept_subscription(client, who)
+      unless allowed?(who)
+        fire('engine_ignored_subscription', who)
+        raise Joggle::Pablotron::Observable::StopEvent, "denied subscription: #{who}"
+      end
+    end
+
+    private 
+
+    def handle_command(who, cmd, arg)
+      # build method name
+      meth = "do_#{cmd}"
+
+      if respond_to?(meth)
+        # return if @tweeter.ignored?(who)
+        fire('engine_command', who, cmd, arg)
+        send("do_#{cmd}", who, arg)
+      else
+        # unknown commands
+        # FIXME: is this the correct behavior?
+        reply(who, "Unknown command: #{cmd}")
+      end
+    end
+
+    def handle_message(who, msg)
+      # remove extraneous whitespace
+      msg, out_msg = msg.strip, nil
+
+      # notify listeners
+      fire('engine_message', who, msg)
+      
+      # make sure message isn't too long
+      if msg.length < 140
+        # make sure message is sane
+        if sane_message?(msg)
+          begin
+            row = @tweeter.tweet(who, msg)
+            out = "Done (id: #{row['id']})"
+          rescue Exception => err
+            out = "Error: #{err.backtrace.first}: #{err.message}"
+          end
+        else
+          out = "Error: Message is too short (try adding more words)"
+        end
+      else
+        out = 'Message length is greater than 140 characters'
+      end
+
+      # send reply
+      reply(who, out)
+    end
+
+    def allowed?(who)
+      # get list of allowed users
+      a = @opt['engine.allow']
+
+      # default to true
+      ret = true
+
+      if a && a.size > 0 
+        ret = a.any? { |str| who.match(/^#{str}/i) }
+      end
+
+      # return result
+      ret
+    end
+
+    #
+    # Get the update interval for the given time
+    # 
+    def get_update_interval(time = Time.now)
+      hour = time.hour
+      default, ranges = %w{default range}.map { |k| @opt["engine.update.#{k}"] }
+
+      if ranges 
+        ranges.each do |key, val|
+          # get start/end hour
+          hours = key.split(/\s*-\s*/).map { |s| s.to_i }
+
+          # if this interval matches the given time, return it
+          if hour >= hours.first && hour <= hours.last
+            return val.to_i
+          end
+        end
+      end
+
+      # return the default interval
+      default.to_i
+    end
+
+    #
+    # Time of the next update
+    #
+    def next_update(time = Time.now)
+      # get the update interval for the given time
+      m = get_update_interval(time)
+      m = 5 if m < 5
+
+      (@last_update || 0) + (m * 60)
+    end
+
+    #
+    # Do we need an update?
+    #
+    def need_update?
+      return true unless @last_update
+
+      # get the current timestamp
+      now = Time.now
+
+      # return true if the last update was more than m minutes ago
+      next_update(now) < now.to_i
+    end
+
+    def update
+      begin
+        if fire('before_engine_update')
+          # save last update time
+          @last_update = Time.now.to_i
+
+          # send updates
+          @tweeter.update do |who, id, time, from, msg|
+            reply(who, make_response(id, time, from, msg))
+          end
+
+          # notify listeners
+          fire('engine_update')
+        else
+          fire('engine_update_stopped')
+        end
+      rescue Exception => err
+        fire('engine_update_error', err)
+      end
+    end
+
+    #
+    # Constraints to prevent garbage tweets.
+    #
+    MESSAGE_SANITY_CHECKS = [
+      # contains at least three consecutive word characters
+      proc { |m| m.match(/\w{3}/) },
+
+      # contains at least three, at least two of which are longer than
+      # three characters
+      proc { |m| 
+        words = m.split(/\s+/)
+        (words.size > 2) && (words.select { |w| w && w.size > 2 }.size > 1)
+      },
+    ]
+
+    def sane_message?(msg)
+      # are sanity checks enabled?
+      return true unless @opt['engine.message_sanity_checks']
+
+      # pass message through all sanity checks
+      MESSAGE_SANITY_CHECKS.all? { |p| p.call(msg) }
+    end
+
+    def make_response(id, time, from, msg)
+      stamp = time.strftime(@opt['engine.time_format'])
+      "%s: %s (%s, #%d)" % [from, msg, stamp, id]
+    end
+  end
+end