joggle 0.1.0

data/lib/joggle/store/pstore/user.rb

@@ -0,0 +1,96 @@
+require 'digest/md5'
+
+module Joggle
+  module Store
+    module PStore
+      #
+      # Mixin that adds user store methods for PStore backend.
+      #
+      # Note: You're probably looking for Joggle::Store::PStore::All
+      #
+      module User
+        #
+        # Add user to store.
+        #
+        def add_user(key, row)
+          key = user_store_key(key)
+
+          @store.transaction do |s|
+            s[key] = row
+          end
+        end
+
+        #
+        # Update user's store entry.
+        #
+        def update_user(key, row)
+          key = user_store_key(key)
+
+          @store.transaction do |s|
+            row.each { |k, v| s[key][k] = v }
+          end
+        end
+
+        #
+        # Get information about given user.
+        #
+        def get_user(key)
+          key = user_store_key(key)
+
+          @store.transaction(true) do |s|
+            s[key]
+          end
+        end
+
+        #
+        # Is the given user ignored?
+        #
+        def ignored?(key)
+          get_user(key)['ignored']
+        end
+
+        #
+        # Does the given user exist?
+        #
+        def has_user?(key)
+          key = user_store_key(key)
+
+          @store.transaction(true) do |s|
+            s.root?(key)
+          end
+        end
+
+        #
+        # Iterate over all users in store.
+        #
+        def each_user(&block) 
+          users = @store.transaction(true) do |s|
+            s.roots.inject([]) do |r, key| 
+              (key =~ /^user-/) ? r << s[key] : r
+            end
+          end
+
+          users.each(&block)
+        end
+
+        #
+        # Delete given user from store.
+        #
+        def delete_user(key)
+          key = user_store_key(key)
+
+          @store.transaction do |s|
+            s.delete(key)
+          end
+        end
+
+        #
+        # Map user key to PStore root key.
+        #
+        def user_store_key(key)
+          'user-' << Digest::MD5.hexdigest(key.gsub(/\/.*$/, ''))
+        end
+      end
+    end
+  end
+end

data/lib/joggle/twitter/engine.rb

@@ -0,0 +1,186 @@
+require 'net/http'
+require 'time'
+require 'joggle/pablotron/observable'
+
+module Joggle
+  module Twitter
+    #
+    # Twitter engine object.
+    #
+    class Engine
+      include Joggle::Pablotron::Observable
+
+      DEFAULTS = {
+        # update interval, in minutes
+        'twitter.engine.update_interval' => 5,
+      }
+
+      #
+      # Create new twitter engine.
+      #
+      def initialize(user_store, fetcher, opt = nil)
+        @opt = DEFAULTS.merge(opt || {})
+        @store = user_store
+        @fetcher = fetcher
+      end
+
+      #
+      # Is the given Jabber user ignored?
+      #
+      def ignored?(who)
+        if rec = @store.get_user(who)
+          rec['ignored']
+        else
+          nil
+        end
+      end
+
+      #
+      # Is the given Jabber registered?
+      #
+      def registered?(who)
+        @store.has_user?(who)
+      end
+
+      #
+      # Bind the given Jabber user to the given Twitter username and
+      # password.
+      #
+      def register(who, user, pass)
+        store = @store
+
+        stoppable_action('twitter_engine_register_user', who, user, pass) do
+          store.add_user(who, { 
+            'who'         => who.gsub(/\/.*$/, ''),
+            'user'        => user,
+            'pass'        => pass,
+            'updated_at'  => 0,
+            'last_id'     => 0,
+            'ignored'     => false,
+            'sleep_bgn'   => 0, # sleep start time, in hours
+            'sleep_end'   => 0, # sleep end time, in hours
+          })
+        end
+      end
+
+      #
+      # Forget registration for the given  Jabber user.
+      #
+      def unregister(who)
+        store = @store
+
+        stoppable_action('twitter_engine_unregister_user', who) do
+          store.delete_user(who)
+        end
+      end
+
+      #
+      # Send a tweet as the given Jabber user.
+      #
+      def tweet(who, msg)
+        ret, store, fetcher = nil, @store, @fetcher
+
+        stoppable_action('twitter_engine_tweet', who, msg) do
+          if user = store.get_user(who)
+            ret = fetcher.tweet(user, msg)
+          end
+        end
+
+        # return result
+        ret
+      end
+
+      #
+      # List recent tweets for the given user.
+      #
+      def list(who, &block)
+        store, fetcher = @store, @fetcher
+
+        stoppable_action('twitter_engine_list', who) do
+          if user = store.get_user(who)
+            fetcher.get(user, true) do |id, who, time, msg|
+              block.call(id, who, time, msg)
+            end
+          end
+        end
+      end
+
+      #
+      # Update all users.
+      #
+      def update(&block) 
+        store, updates = @store, []
+
+        # make list of updates
+        @store.each_user do |user|
+          updates << user if needs_update?(user)
+        end
+
+        # iterate over updates and do each one
+        updates.each do |user|
+          stoppable_action('twitter_engine_update', user) do
+            update_user(user) do |id, time, src, msg|
+              block.call(user['who'], id, time, src, msg)
+            end
+          end
+        end
+      end
+
+      private
+
+      #
+      # Update specific Jabber user.
+      #
+      def update_user(user, &block)
+        last_id = nil
+
+        @fetcher.get(user) do |id, who, time, msg|
+          last_id = id
+          block.call(id, who, time, msg)
+        end
+
+        @store.update_user(user['who'], {
+          'last_id'    => last_id,
+          'updated_at' => Time.now.to_i,
+        })
+      end
+
+      #
+      # Does the given Jabber user need an update?
+      #
+      def needs_update?(user)
+        now, since = Time.now, Time.now - @opt['twitter.engine.update_interval']
+
+        # check update interval
+        if user['updated_at'].to_i < since.to_i
+          # check sleep interval
+          !is_sleeping?(user, now)
+        else
+          # updated within update_interval
+          false
+        end
+      end
+
+      #
+      # Is the given Jabber user asleep?
+      #
+      def is_sleeping?(user, time = Time.now)
+        # build sleep range
+        sleep = %w{bgn end}.map { |s| user["sleep_#{s}"].to_i }
+
+        # compare user sleep time
+        time.hour >= sleep.first && time.hour <= sleep.last
+      end
+
+      #
+      # Fire a stoppable event.
+      #
+      def stoppable_action(key, *args, &block)
+        if fire("before_#{key}", *args)
+          block.call
+          fire(key, *args)
+        end
+      end
+    end
+  end
+end

data/lib/joggle/twitter/fetcher.rb

@@ -0,0 +1,123 @@
+require 'uri'
+require 'net/http'
+require 'openssl'
+require 'json'
+require 'joggle/pablotron/cache'
+
+module Joggle
+  module Twitter
+    #
+    # Handler for Twitter HTTP requests.
+    #
+    class Fetcher
+      DEFAULTS = {
+        'twitter.fetcher.url.timeline' => 'https://twitter.com/statuses/friends_timeline.json',
+        'twitter.fetcher.url.tweet'    => 'https://twitter.com/statuses/update.json',
+      }
+
+      #
+      # Create a new Twitter::Fetcher object.
+      #
+      def initialize(message_store, cache, opt = {})
+        @opt = DEFAULTS.merge(opt || {})
+        @store = message_store
+        @cache = cache
+      end
+
+      #
+      # Get Twitter updates for given user and pass them to the
+      # specified block.
+      #
+      def get(user, show_all = false, &block)
+        url, opt = url_for(user, 'timeline'), opt_for(user)
+
+        if data = @cache.get(url, opt)
+          JSON.parse(data).reverse.each do |row|
+            cached = @store.has_message?(row['id'])
+
+            if show_all || !cached
+              # cache message
+              @store.add_message(row['id'], row)
+
+              # send to parent
+              block.call(
+                row['id'], 
+                Time.parse(row['created_at']), 
+                row['user']['screen_name'], 
+                row['text']
+              )
+            end
+          end
+        end
+      end
+
+      #
+      # Send a tweet.  Use Joggle::Engine#tweet instead.
+      #
+      def tweet(user, msg)
+        # build URI and headers (opt)
+        url, opt = url_for(user, 'tweet'), opt_for(user)
+        uri = URI.parse(url)
+        ret = nil
+
+        # build post data
+        data = {
+          'status' => msg,
+        }.map { |a| 
+          a.map { |v| CGI.escape(v) }.join('=') 
+        }.join('&')
+
+        # FIXME: add user-agent to headers
+        req = Net::HTTP.new(uri.host, uri.port)
+        req.use_ssl = (uri.scheme == 'https')
+
+        # start http request
+        req.start do |http|
+          # post request
+          r = http.post(uri.path, data, opt)
+
+          # check response
+          case r
+          when Net::HTTPSuccess
+            ret = JSON.parse(r.body)
+
+            # File.open('/tmp/foo.log', 'a') do |fh|
+            #   fh.puts "r.body = #{r.body}"
+            # end
+
+            # check result
+            if ret && ret.key?('id')
+              @store.add_message(ret['id'], ret)
+            else
+              throw "got weird response from twitter"
+            end
+          else
+            throw r
+          end
+        end
+
+        # return result
+        ret
+      end
+
+      private
+
+      def url_for(user, key)
+        args = nil
+
+        if false && key == 'timeline'
+          if user['last_id'] && user['last_id'] > 0
+            args = { 'since_id' => user['last_id'] }
+          end
+        end
+
+        Joggle::Pablotron::Cache.urlify(@opt['twitter.fetcher.url.' + key], args)
+      end
+
+      def opt_for(user)
+        str = ["#{user['user']}:#{user['pass']}"].pack('m').strip
+        { 'Authorization' => 'Basic ' + str }
+      end
+    end
+  end
+end

data/lib/joggle/version.rb

@@ -0,0 +1,6 @@
+module Joggle
+  #
+  # Joggle release version.
+  #
+  VERSION = '0.1.0'
+end