twat 0.6.3 → 0.9.2

data/lib/twat/subcommand.rb

@@ -0,0 +1,34 @@
+%w(base add config delete follow_tag follow list mentions set update update_config finger version track).each do |filename|
+  require File.join(File.expand_path("../subcommands/#{filename}", __FILE__))
+end
+
+module Twat
+  class Subcommand
+
+    def self.run
+      # This is evilbadscary, but seems like the best approach
+      $args = ::Twat::Args.new
+      # First, without commands dump user into follow mode
+      if ARGV.empty?
+        ARGV.insert(0, "follow_tag")
+
+      # Failing that, in the case of invalid commands, assume they want to
+      # tweet something.
+      # TODO, fuzzy match against the contents of COMMANDS and have a sook if
+      # they're close to an actual command
+      # FIXME Potentially the absense of a space would suggest that it's just a
+      # fucked effort at typing
+      elsif !Subcommands::COMMANDS.include?(ARGV[0])
+        ARGV.insert(0, "update")
+      end
+
+      # There is really no reason why this needs to be explicitly mention
+      # in this layout, we could just as easily look for a class in
+      # Subcommands:: that matches by name, however this avoids some ugly
+      # metaprogramming with minimal overhead, and also leaves the door
+      # open for aliasing etc
+      Subcommands::COMMANDS[ARGV[0]].new(ARGV[1..-1]).run!
+    end
+
+  end
+end

data/lib/twat/subcommands/add.rb

@@ -0,0 +1,17 @@
+module Twat::Subcommands
+  class Add < Base
+
+    def run
+      needs_arguments(1)
+
+      endpoint = ::Twat::Endpoint.new(args.endpoint)
+      endpoint.authorize_account(@argv[0])
+    end
+
+    def self.usage
+       "Usage: twat add accountname"
+    end
+
+  end
+  COMMANDS['add'] = Add
+end

data/lib/twat/subcommands/base.rb

@@ -0,0 +1,122 @@
+module ::Twitter
+  class Status
+    def as_user
+      begin
+        user.screen_name
+      rescue NoMethodError
+        from_user
+      end
+    end
+  end
+end
+
+module Twat::Subcommands
+  COMMANDS = {}
+  class Base
+
+    include ::Twat::Exceptions
+
+    attr_reader :opts
+
+    def initialize(argv)
+      @argv=argv
+    end
+
+    def run!
+      with_handled_exceptions(args) do
+        run
+      end
+    end
+
+    def needs_arguments(n)
+      unless @argv.length == n
+        usage_and_exit!
+      end
+    end
+
+    def needs_at_least(n)
+      unless @argv.length >= n
+        usage_and_exit!
+      end
+    end
+
+    def usage_and_exit!
+      usage
+      exit
+    end
+
+    def auth!
+      Twitter.configure do |twit|
+        config.account.each do |key, value|
+          twit.send("#{key}=", value)
+        end
+        config.endpoint.consumer_info.each do |key, value|
+          twit.send("#{key}=", value)
+        end
+        twit.endpoint = config.endpoint.url
+      end
+    end
+
+    def beep
+      print "\a"
+    end
+
+    def pad(n)
+      "%02d" % n
+    end
+
+    # Format a tweet all pretty like
+    def format(twt, idx = nil)
+      idx = pad(idx) if idx
+      text = deentitize(twt.text)
+      if config.colors?
+        buf = idx ? "#{idx.cyan}:" : ""
+        if twt.as_user == config.account_name.to_s
+          buf += "#{twt.as_user.bold.blue}: #{text}"
+        elsif text.mentions?(config.account_name)
+          buf += "#{twt.as_user.bold.red}: #{text}"
+        else
+          buf += "#{twt.as_user.bold.cyan}: #{text}"
+        end
+        buf.colorise!
+      else
+        buf = idx ? "#{idx}: " : ""
+        buf += "#{twt.as_user}: #{text}"
+      end
+    end
+
+    def deentitize(text)
+      {"&lt;" => "<", "&gt;" => ">", "&amp;" => "&", "&quot;" => '"' }.each do |k,v|
+        text.gsub!(k, v)
+      end
+      text
+    end
+
+    def config
+      @config ||= ::Twat::Config.new
+    end
+
+    def opts
+      @opts ||= ::Twat::Options.new
+    end
+
+    def args
+      # This is dangerous, but realistically I don't see how else to parse the
+      # args before creating an instance of a subclass
+      @args ||= $args
+    end
+
+    def enable_readline!
+      @reader = ReadlineNG::Reader.new
+    end
+
+    def reader
+      @reader
+    end
+
+    def usage
+      puts self.class.usage
+    end
+
+  end
+end

data/lib/twat/subcommands/config.rb

@@ -0,0 +1,15 @@
+module Twat::Subcommands
+  class Config < Base
+
+    def run
+      raise AlreadyConfigured if config.exists?
+      config.create!
+    end
+
+    def self.usage
+      "Usage: twat config"
+    end
+
+  end
+  COMMANDS['config'] = Config
+end

data/lib/twat/subcommands/delete.rb

@@ -0,0 +1,24 @@
+module Twat::Subcommands
+  class Delete < Base
+
+    def run
+      needs_arguments(1)
+      if config.accounts.delete(@argv[0])
+        config.save!
+        puts "Successfully deleted"
+      else
+        puts "No such account"
+      end
+    end
+
+    def self.usage
+      "Usage: twat delete ACCOUNTNAME"
+    end
+
+    def updateconfig
+      config.update!
+    end
+
+  end
+  COMMANDS['delete'] = Delete
+end

data/lib/twat/subcommands/finger.rb

@@ -0,0 +1,23 @@
+module Twat::Subcommands
+  class Finger < Base
+
+    def run
+      needs_at_least(1)
+      auth!
+
+      begin
+        Twitter.user_timeline(@argv[0], :count => (@argv[1] || 1).to_i).each do |tweet|
+          puts format(tweet)
+        end
+      # rescue Twitter::NotFound
+      #   puts "#{@argv[0].bold.red} doesn't appear to be a valid user"
+      end
+    end
+
+    def self.usage
+      "Usage: twat finger USERNAME [count]"
+    end
+
+  end
+  COMMANDS['finger'] = Finger
+end

data/lib/twat/subcommands/follow.rb

@@ -0,0 +1,18 @@
+module Twat::Subcommands
+  class Follow < Base
+
+    def run
+      needs_arguments(1)
+      auth!
+
+      Twitter.follow(@argv[0])
+    end
+
+    def self.usage
+      "Usage: twat follow USERNAME"
+    end
+
+  end
+  COMMANDS['follow'] = Follow
+end
+

data/lib/twat/subcommands/follow_tag.rb

@@ -0,0 +1,19 @@
+module Twat::Subcommands
+  class FollowTag < Base
+    include FollowMixin
+
+    def self.usage
+      ["Usage: twat",
+        "Usage: twat follow_stream #hashtag"]
+    end
+
+    def new_tweets(opts)
+      unless @argv.empty?
+        ret = Twitter.search(@argv.join(" "), opts)
+      else
+        ret = Twitter.home_timeline(opts)
+      end
+    end
+  end
+  COMMANDS['follow_tag'] = FollowTag
+end

data/lib/twat/subcommands/list.rb

@@ -0,0 +1,17 @@
+module Twat::Subcommands
+  class List < Base
+
+    def run
+      auth!
+      Twitter.home_timeline(:count => @argv[0] || 5).reverse.each do |tweet|
+        format(tweet)
+      end
+    end
+
+    def self.usage
+      "Usage: twat list [count]"
+    end
+
+  end
+  COMMANDS['list'] = List
+end

data/lib/twat/subcommands/mentions.rb

@@ -0,0 +1,20 @@
+module Twat::Subcommands
+  class Mentions < Base
+  include FollowMixin
+
+  def run
+    needs_arguments(0)
+    super
+  end
+
+  def self.usage
+    "Usage: twat mentions"
+  end
+
+  def new_tweets(opts)
+    ret = Twitter.mentions(opts)
+  end
+
+  end
+  COMMANDS['mentions'] = Mentions
+end

data/lib/twat/subcommands/set.rb

@@ -0,0 +1,19 @@
+module Twat::Subcommands
+  class Set < Base
+
+    def run
+      needs_arguments(2)
+      k, v = @argv[0..1]
+      opts.send(:"#{k}=", v)
+
+      puts "Successfully set #{k} as #{v}"
+    end
+
+    def self.usage
+      "Usage: twat set option value"
+      # TODO Dump available options
+    end
+
+  end
+  COMMANDS['set'] = Set
+end

data/lib/twat/subcommands/track.rb

@@ -0,0 +1,33 @@
+require 'ostruct'
+module Twat::Subcommands
+  class Track < Base
+    include FollowMixin
+
+    # TODO configless mixin
+    def auth! # Disable authentication
+    end
+
+    def config # Stub out a config object
+      @_config ||= if (c = super).exists?
+                     c
+                   else
+                     OpenStruct.new({
+                       :polling_interval => 60,
+                       :colors? => true,
+                       :beep? => false,
+                       :account_name => "IMPOSSIBLEUSERNAME!"
+                     })
+                   end
+    end
+
+    def self.usage
+      ["Usage: twat track username"]
+    end
+
+    def new_tweets(opts)
+      Twitter.user_timeline(@argv[0], opts)
+    end
+
+  end
+  COMMANDS['track'] = Track
+end

data/lib/twat/subcommands/update.rb

@@ -0,0 +1,21 @@
+module Twat::Subcommands
+  class Update < Base
+
+    def run
+      msg = @argv.join(" ")
+      raise TweetTooLong if msg.length > 140
+      usage_and_exit! if msg == ""
+
+      auth!
+
+      Twitter.update(msg)
+      #puts msg
+    end
+
+    def self.usage
+      "Usage: twat update tweet goes here"
+    end
+
+  end
+  COMMANDS['update'] = Update
+end

data/lib/twat/subcommands/update_config.rb

@@ -0,0 +1,16 @@
+module Twat::Subcommands
+  class UpdateConfig < Base
+
+    def run
+
+      config.update_config
+
+    end
+
+    def self.usage
+      "Usage: twat update_config"
+    end
+
+  end
+  COMMANDS['update_config'] = UpdateConfig
+end

data/lib/twat/subcommands/version.rb

@@ -0,0 +1,14 @@
+module Twat::Subcommands
+  class Version < Base
+
+    def run
+      puts "twat: #{Twat::VERSION}"
+    end
+
+    def self.usage
+      "Usage: twat version"
+    end
+
+  end
+  COMMANDS['version'] = Version
+end

data/lib/twat/tweetstack.rb

@@ -0,0 +1,38 @@
+module Twat
+  class TweetStack
+    # A circularly linked list representing all of the tweets printed thus far,
+    # for the purposes of retrieving them after being printed
+    def initialize
+      @stack = {}
+      @_next = 0
+    end
+
+    def [] k
+      @stack[k]
+    end
+
+    def << v
+      @stack[nxt] = v
+    end
+
+    def include? k
+      @stack.keys.include?(k)
+    end
+
+    def last
+      # I see the irony
+      @_next
+    end
+
+    private
+
+    def nxt
+      if @_next == 99
+        @_next = 1
+      else
+        @_next += 1
+      end
+    end
+
+  end
+end