mattmueller-twibot 0.1.7.1

data/History.txt

@@ -0,0 +1,50 @@
+== 0.1.7 / 2009-06-01
+
+* New feature - choose how Twibot processes incoming tweets on startup
+  (process all, process new [old behaviour], or process from a given ID)
+  Bodaniel Jeanes
+* Substantially improved error handling. Now survives all common network
+  stability issues
+* Added a host configuration option. The host name is displayed along all
+  output from Twibot. Currently Twitter4R does nothing with this option,
+  Twibot knowing about it should make it easier to put Twibot/Twitter4R on
+  other services like Laconica instances
+
+== 0.1.6 / 2009-04-13
+
+* Fixed configure block not actually working for username and password
+  Bodaniel Jeanes
+* Minor updates in tests
+
+== 0.1.5 / 2009-04-12
+
+* Added support for regular expression routes
+* Make timeline_for option configurable, ie in config: timeline_for: :public
+* Fixed bug: Users where unlawfully rejected when their screen name started with
+             a capital letter (Wilco)
+* Fixed bug: Twibot crashed if there were no handlers registered
+
+== 0.1.4 / 2009-03-24
+
+* Removed some warnings
+* Added error handling to avoid Twibot crashing when Twitter is down (Ben Vandgrift)
+* Fixed bug: receiving tweets from named users crashed Twibot (Jens Ohlig)
+
+== 0.1.3 / 2009-03-19
+
+* Ruby 1.9 support
+
+== 0.1.2 / 2009-03-18
+
+* Removed some warnings
+* Applied patch from Dan Van Derveer fixing a few minor bugs related to the
+  options hash sent to Twitter4R
+
+== 0.1.1 / 2009-03-15
+
+* Fixed dependency
+
+== 0.1.0 / 2009-03-15
+
+* 1 major enhancement
+  * Birthday!

data/Rakefile

@@ -0,0 +1,30 @@
+# Look in the tasks/setup.rb file for the various options that can be
+# configured in this Rakefile. The .rake files in the tasks directory
+# are where the options are used.
+
+begin
+  require 'bones'
+  Bones.setup
+rescue LoadError
+  begin
+    load 'tasks/setup.rb'
+  rescue LoadError
+    raise RuntimeError, '### please install the "bones" gem ###'
+  end
+end
+
+ensure_in_path 'lib'
+require 'twibot'
+
+task :default => 'test:run'
+
+PROJ.name = 'twibot'
+PROJ.authors = 'Christian Johansen'
+PROJ.email = 'christian@cjohansen.no'
+PROJ.url = 'http://github.com/bjeanes/twibot/'
+PROJ.version = Twibot::VERSION
+PROJ.rubyforge.name = 'twibot'
+PROJ.readme_file = 'Readme.rdoc'
+PROJ.rdoc.remote_dir = 'twibot'
+
+depend_on "mbbx6spp-twitter4r", "0.3.1"

data/Readme.rdoc

@@ -0,0 +1,269 @@
+= Twibot
+Official URL: http://github.com/cjohansen/twibot/tree/master
+Christian Johansen (http://www.cjohansen.no)
+Twitter: @cjno
+
+== Description
+
+Twibot (pronounced like "Abbot"), is a Ruby microframework for creating Twitter
+bots, heavily inspired by Sinatra.
+
+== Usage
+
+=== Simple example
+
+  require 'twibot'
+
+  # Receive messages, and tweet them publicly
+  #
+  message do |message, params|
+    post_tweet message
+  end
+
+  # Respond to @replies if they come from the right crowd
+  #
+  reply :from => [:cjno, :irbno] do |message, params|
+    post_reply message, "I agree"
+  end
+
+  # Listen in and log tweets
+  #
+  tweet do |message, params|
+    MyApp.log_tweet(message)
+  end
+  
+  # Search for tweets matching a query.  The available search operators
+  # are explained here: <http://search.twitter.com/operators>
+  #
+  search "twibot" do |message, params|
+    # do_something
+  end
+  
+  # Search for tweets with a hashtag
+  #  see: <http://twitter.pbworks.com/Hashtags>
+  #
+  # Note: hashtag is just a convenience wrapper
+  # around search.  It will invoke the search
+  # before and after filters.
+  #
+  hashtag "twibot" do |message, params|
+    # do_something
+  end
+  
+  # Search for tweets with one of a number of hashtags
+  #  see: <http://twitter.pbworks.com/Hashtags>
+  #
+  # Note: hashtags is just an alias to hashtag
+  #
+  hashtags [:twibot, :ruby, "twitter4r"] do |message, params|
+    # do_something
+  end
+  
+  # Process any new followers.  user_id will be
+  # the user's Numeric id and params will always
+  # be an empty Hash.
+  #
+  # add_friend!(id) is a convenience wrapper around the
+  # twitter4r friendship method.  remove_friend!(id)
+  # is also available.
+  #
+  follower do |user_id, params|
+    # keep out the riff-raff...
+    bot.add_friend!(user_id) unless user_id == 890631
+  end
+  
+  # add some set-up code that will be called
+  # before each polling cycle.  :all is the
+  # default, so it can safely be omitted
+  #
+  before :all do
+    MyApp.log("Started polling at #{Time.now}")
+  end
+  
+  # the after hook for the polling cycle gets
+  # passed the number of messages that were
+  # processed
+  #
+  after :all do |message_count|
+    MyApp.log("Finished polling at #{Time.now}.  Got #{message_count} messages.")
+  end
+  
+  # each action has before and after hooks available:
+  #  - follower
+  #  - message
+  #  - reply
+  #  - search
+  #  - tweet
+  #
+  # there can be only one before and one after callback
+  # registered for a given type.  the callback block
+  # will be called with no arguments.
+  #
+  # Note: hashtag and hashtags are just wrappers around
+  # search and do not have their own hooks.  Use the
+  # search hooks when using hashtag or hashtags.
+  #
+  before :message do
+    MyApp.is_processing_a_message = true
+  end
+  
+  after :message do
+    MyApp.is_processing_a_message = false
+  end
+  
+  after :follower do
+    MyApp.log("I have another follower!")
+  end
+
+
+=== Running the bot
+
+To run the bot, simply do:
+
+  ruby bot.rb
+
+=== Configuration
+
+Twibot looks for a configuration file in ./config/bot.yml. It should contain
+atleast:
+
+  login: twitter_login
+  password: twitter_password
+
+You can also pass configuration as command line arguments:
+
+  ruby bot.rb --login myaccount
+
+...or configure with Ruby:
+
+  configure do |conf|
+    conf.login = "my_account"
+  do
+
+If you don't specify login and/or password in any of these ways, Twibot will
+prompt you for those.
+
+If you want to change how Twibot is configured, you can setup the bot instance
+manually and give it only the configuration options you want:
+
+  # Create bot only with default configuration
+  require 'twibot'
+  bot = Twibot::Bot.new(Twibot::Config.default)
+
+  # Application here...
+
+If you want command line arguments you can do:
+
+  require 'twibot'
+  bot = Twibot::Bot.new(Twibot::Config.default << Twibot::CliConfig.new)
+
+To disable the buffering of the Twibot log file, set the `log_flush` config
+option to `true`:
+
+  configure do |conf|
+    conf.log_file = File.join(DAEMON_ROOT, 'log', 'twitterd.log')
+    conf.log_level = "info"
+    conf.log_flush = true
+  end
+
+=== "Routes"
+
+Like Sinatra, and other web app frameworks, Twibot supports "routes": patterns
+to match incoming tweets and messages:
+
+  require 'twibot'
+
+  tweet "time :country :city" do |message,params|
+    time = MyTimeService.lookup(params[:country], params[:city])
+    client.message :post, "Time is #{time} in #{params[:city]}, #{params[:country]}"
+  end
+
+You can have several "tweet" blocks (or "message" or "reply"). The first one to
+match an incoming tweet/message will handle it.
+
+As of the upcoming 0.1.5/0.2.0, Twibot also supports regular expressions as routes:
+
+  require 'twibot'
+
+  tweet /^time ([^\s]*) ([^\s]*)/ do |message, params|
+    # params is an array of matches when using regexp routes
+    time = MyTimeService.lookup(params[0], params[1])
+    client.message :post, "Time is #{time} in #{params[:city]}, #{params[:country]}"
+  end
+
+=== Working with the Twitter API
+
+The DSL gives you access to your Twitter client instance through "client" (or "twitter"):
+
+  message do
+    twitter.status :post, "Hello world" # Also: client.status :post, "Hello world"
+  end
+
+== Requirements
+
+Twitter4r. You'll need atleast 0.3.1, which is currently only available from GitHub.
+Versions of Twitter4r prior to 0.3.1 does not allow for the since_id parameter to be
+appended to URLs to the REST API. Twibot needs these to only fetch fresh messages
+and tweets.
+
+== Installation
+
+gem install twibot
+
+== Is it Ruby 1.9?
+
+As of Twibot 0.1.3, yes it is! All tests pass, please give feedback from real world
+usage if you have trouble.
+
+== Polling
+
+Twitter pulled the plug on it's xmpp service last year. This means that Twibot backed
+bots needs to poll the Twitter service to keep up. Twitter has a request limit on 70
+reqs/hour, so you should configure your bot not to make more than that, else it will
+fail. You can ask for your bot account to be put on the whitelist which allows you to
+make 20.000 reqs/hour, and shouldn't be a problem so long as your intentions are good
+(I think).
+
+Twibot polls like this:
+* Poll messages if any message handlers exist
+* Poll tweets if any tweet or reply handlers exist
+* Sleep for +interval+ seconds
+* Go over again
+
+As long as Twibot finds any messages and/or tweets, the interval stays the same
+(min_interval configuration switch). If nothing was found however, the interval to
+sleep is increased by interval_step configuration option. This happens until it
+reaches max_interval, where it will stay until Twibot finds anything.
+
+== Contributors
+
+* Dan Van Derveer (bug fixes) - http://dan.van.derveer.com/
+* Ben Vandgrift (Twitter downtime error handling) - http://neovore.com/
+* Jens Ohlig (warnings)
+* Wilco van Duinkerken (bug fixes) - http://www.sparkboxx.com/
+* Bodaniel Jeanes (configure block fix) - http://bjeanes.github.com/
+
+== License
+
+(The MIT License)
+
+Copyright (c) 2009 Christian Johansen
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/lib/hash.rb

@@ -0,0 +1,8 @@
+class Hash
+  def symbolize_keys!
+    replace(inject({}) do |hash,(key,value)|
+      hash[key.to_sym] = value.is_a?(Hash) ? value.symbolize_keys! : value
+      hash
+    end)
+  end
+end

data/lib/twibot.rb

@@ -0,0 +1,87 @@
+require 'time'
+require 'twitter'
+require 'twitter/client'
+require 'yaml'
+require File.join(File.dirname(__FILE__), 'hash')
+
+module Twibot
+
+  # :stopdoc:
+  VERSION = '0.1.7'
+  LIBPATH = ::File.expand_path(::File.dirname(__FILE__)) + ::File::SEPARATOR
+  PATH = ::File.dirname(LIBPATH) + ::File::SEPARATOR
+  # :startdoc:
+
+  # Returns the version string for the library.
+  #
+  def self.version
+    VERSION
+  end
+
+  # Returns the library path for the module. If any arguments are given,
+  # they will be joined to the end of the libray path using
+  # <tt>File.join</tt>.
+  #
+  def self.libpath( *args )
+    args.empty? ? LIBPATH : ::File.join(LIBPATH, args.flatten)
+  end
+
+  # Returns the lpath for the module. If any arguments are given,
+  # they will be joined to the end of the path using
+  # <tt>File.join</tt>.
+  #
+  def self.path( *args )
+    args.empty? ? PATH : ::File.join(PATH, args.flatten)
+  end
+
+  # Utility method used to require all files ending in .rb that lie in the
+  # directory below this file that has the same name as the filename passed
+  # in. Optionally, a specific _directory_ name can be passed in such that
+  # the _filename_ does not have to be equivalent to the directory.
+  #
+  def self.require_all_libs_relative_to( fname, dir = nil )
+    dir ||= File.basename(fname, '.*')
+    search_me = File.expand_path(File.join(File.dirname(fname), dir, '**', '*.rb'))
+    Dir.glob(search_me).sort.each {|rb| require rb }
+  end
+
+  @@app_file = lambda do
+    ignore = [
+      /lib\/twibot.*\.rb/, # Library
+      /\(.*\)/,            # Generated code
+      /custom_require\.rb/ # RubyGems require
+    ]
+
+    path = caller.map { |line| line.split(/:\d/, 2).first }.find do |file|
+      next if ignore.any? { |pattern| file =~ pattern }
+      file
+    end
+
+    path || $0
+  end.call
+
+  #
+  # File name of the application file. Inspired by Sinatra
+  #
+  def self.app_file
+    @@app_file
+  end
+
+  #
+  # Runs application if application file is the script being executed
+  #
+  def self.run?
+    self.app_file == $0
+  end
+
+end  # module Twibot
+
+Twitter::Client.configure do |config|
+  config.application_name = 'Twibot'
+  config.application_version = Twibot.version
+  config.application_url = 'http://github.com/cjohansen/twibot'
+end
+
+Twibot.require_all_libs_relative_to(__FILE__)
+
+# EOF

data/lib/twibot/bot.rb

@@ -0,0 +1,422 @@
+require 'logger'
+require File.join(File.expand_path(File.dirname(__FILE__)), 'macros')
+require File.join(File.expand_path(File.dirname(__FILE__)), 'handlers')
+
+module Twibot
+  #
+  # Main bot "controller" class
+  #
+  class Bot
+    include Twibot::Handlers
+    attr_reader :twitter
+    attr_writer :prompt
+
+    def initialize(options = nil, prompt = false)
+      @prompt = prompt
+      @conf = nil
+      @config = options || Twibot::Config.default << Twibot::FileConfig.new << Twibot::CliConfig.new
+      @log = nil
+      @abort = false
+    rescue Exception => krash
+      raise SystemExit.new(krash.message)
+    end
+
+    def prompt?
+      @prompt
+    end
+
+    def processed
+      @processed ||= {
+        :message => nil,
+        :reply => nil,
+        :tweet => nil,
+        :search => {}
+      }
+    end
+
+    def twitter
+      @twitter ||= Twitter::Client.new(:login => config[:login],
+                                       :password => config[:password],
+                                       :host => config[:host])
+    end
+
+    #
+    # Run application
+    #
+    def run!
+      puts "Twibot #{Twibot::VERSION} imposing as @#{login} on #{config[:host]}"
+
+      trap(:INT) do
+        puts "\nAnd it's a wrap. See ya soon!"
+        exit
+      end
+
+      case config[:process]
+      when :all, nil
+        # do nothing so it will fetch ALL
+      when :new
+        # Make sure we don't process messages and tweets received prior to bot launch
+        messages = twitter.messages(:received, { :count => 1 })
+        processed[:message] = messages.first.id if messages.length > 0
+
+        handle_tweets = !handlers.nil? && handlers_for_type(:tweet).length + handlers_for_type(:reply).length + handlers_for_type(:search).keys.length > 0
+        # handle_tweets ||= handlers_for_type(:search).keys.length > 0
+        tweets = []
+
+        sandbox do
+          tweets = handle_tweets ? twitter.timeline_for(config[:timeline_for], { :count => 1 }) : []
+        end
+
+        processed[:tweet] = tweets.first.id if tweets.length > 0
+        processed[:reply] = tweets.first.id if tweets.length > 0
+
+        # for searches, use latest tweet on public timeline
+        #
+        if handle_tweets && config[:timeline_for].to_s != "public"
+          sandbox { tweets = twitter.timeline_for(:public, { :count => 1 }) }
+        end
+        if tweets.length > 0
+          handlers_for_type(:search).each_key {|q| processed[:search][q] = tweets.first.id }
+        end
+
+        load_followers
+
+      when Numeric, /\d+/ # a tweet ID to start from
+        processed[:tweet] = processed[:reply] = processed[:message] = config[:process]
+        handlers[:search].each_key {|q| processed[:search][q] = config[:process] }
+      else abort "Unknown process option #{config[:process]}, aborting..."
+      end
+
+      load_friends unless handlers_for_type(:follower).empty?
+
+      poll
+    end
+
+    #
+    # Poll Twitter API in a loop and pass on messages and tweets when they appear
+    #
+    def poll
+      max = max_interval
+      step = interval_step
+      interval = min_interval
+
+      while !@abort do
+        run_hook :before_all
+        message_count = 0
+        message_count += receive_messages || 0
+        message_count += receive_replies || 0
+        message_count += receive_tweets || 0
+        message_count += receive_searches || 0
+
+        receive_followers
+
+        run_hook :after_all, message_count
+
+        interval = message_count > 0 ? min_interval : [interval + step, max].min
+
+        log.debug "#{config[:host]} sleeping for #{interval}s"
+        sleep interval
+      end
+    end
+
+
+    def friend_ids
+      @friend_ids ||= {}
+    end
+
+    def add_friend!(user_or_id, only_local=false)
+      id = id_for_user_or_id(user_or_id)
+      sandbox(0) { twitter.friend(:add, id) } unless only_local
+      friend_ids[id] = true
+    end
+
+    def remove_friend!(user_or_id, only_local=false)
+      id = id_for_user_or_id(user_or_id)
+      sandbox(0) { twitter.friend(:remove, id) } unless only_local
+      friend_ids[id] = false
+    end
+
+    def is_friend?(user_or_id)
+      !!friend_ids[id_for_user_or_id(user_or_id)]
+    end
+
+    def follower_ids
+      @follower_ids ||= {}
+    end
+
+    def add_follower!(user_or_id)
+      follower_ids[id_for_user_or_id(user_or_id)] = true
+    end
+
+    def remove_follower!(user_or_id)
+      follower_ids[id_for_user_or_id(user_or_id)] = false
+    end
+
+    def is_follower?(user_or_id)
+      !!follower_ids[id_for_user_or_id(user_or_id)]
+    end
+
+    def id_for_user_or_id(user_or_id)
+      (user_or_id.respond_to?(:screen_name) ? user_or_id.id : user_or_id).to_i
+    end
+
+
+    #
+    # retrieve a list of friend ids and store it as a Hash
+    #
+    def load_friends
+      sandbox(0) do
+        twitter.graph(:friends, config[:login]).each {|id| add_friend!(id, true) }
+      end
+    end
+
+    #
+    # retrieve a list of friend ids and store it as a Hash
+    #
+    def load_followers
+      sandbox(0) do
+        twitter.graph(:followers, config[:login]).each {|id| add_follower!(id) }
+      end
+    end
+
+
+    #
+    # returns a Hash of all registered hooks
+    #
+    def hooks
+      @hooks ||= {}
+    end
+
+    #
+    # registers a block to be called at the given +event+
+    #
+    def add_hook(event, &blk)
+      hooks[event.to_sym] = blk
+    end
+
+    #
+    # calls the hook method for the +event+ if one has
+    # been defined
+    #
+    def run_hook(event, *args)
+      hooks[event.to_sym].call(*args) if hooks[event.to_sym].respond_to? :call
+    end
+
+    #
+    # Receive direct messages
+    #
+    def receive_messages
+      type = :message
+      return false unless handlers_for_type(type).length > 0
+      options = {}
+      options[:since_id] = processed[type] if processed[type]
+
+      sandbox(0) do
+        dispatch_messages(type, twitter.messages(:received, options), %w{message messages})
+      end
+    end
+
+    #
+    # Receive tweets
+    #
+    def receive_tweets
+      type = :tweet
+      return false unless handlers_for_type(type).length > 0
+      options = {}
+      options[:since_id] = processed[type] if processed[type]
+
+      sandbox(0) do
+        dispatch_messages(type, twitter.timeline_for(config.to_hash[:timeline_for] || :public, options), %w{tweet tweets})
+      end
+    end
+
+    #
+    # Receive tweets that start with @<login>
+    #
+    def receive_replies
+      type = :reply
+      return false unless handlers_for_type(type).length > 0
+      options = {}
+      options[:since_id] = processed[type] if processed[type]
+
+      sandbox(0) do
+        dispatch_messages(type, twitter.status(:replies, options), %w{reply replies})
+      end
+    end
+
+    #
+    # Receive tweets that match the query parameters
+    #
+    def receive_searches
+      result_count = 0
+
+      handlers_for_type(:search).each_pair do |query, search_handlers|
+        options = { :q => query, :rpp => 100 }
+        [:lang, :geocode].each do |param|
+          options[param] = search_handlers.first.options[param] if search_handlers.first.options[param]
+        end
+        options[:since_id] = processed[:search][query] if processed[:search][query]
+
+        result_count += sandbox(0) do
+          dispatch_messages([:search, query], twitter.search(options.merge(options)), %w{tweet tweets}.map {|l| "#{l} for \"#{query}\""})
+        end
+      end
+
+      result_count
+    end
+
+    #
+    # Receive any new followers
+    #
+    def receive_followers
+      newbies = []
+      sandbox(0) do
+        twitter.graph(:followers, config[:login]).each {|id| newbies << id unless is_friend?(id) or is_follower?(id) }
+        newbies.each do |id|
+          add_follower!(id)
+          with_hooks(:follower) { handlers_for_type(:follower).each {|h| h.handle(id, {}) } }
+        end
+      end
+      log.info "#{config[:host]}: Received #{newbies.size} new #{newbies.size == 1 ? 'follower' : 'followers'}"
+    end
+
+    #
+    # Dispatch a collection of messages
+    #
+    def dispatch_messages(type, messages, labels)
+      messages.each {|message| with_hooks(type) { dispatch(type, message) } }
+      # Avoid picking up messages over again
+      if type.is_a? Array            # [TODO] (mikedemers) this is an ugly hack
+        processed[type.first][type.last] = messages.first.id if messages.length > 0
+      else
+        processed[type] = messages.first.id if messages.length > 0
+      end
+
+      num = messages.length
+      log.info "#{config[:host]}: Received #{num} #{num == 1 ? labels[0] : labels[1]}"
+      num
+    end
+
+    #
+    # invokes the given block, running the before and
+    # after hooks for the given type
+    #
+    def with_hooks(type, &blk)
+      event = type.is_a?(Array) ? type.first : type
+      run_hook :"before_#{event}"
+      value = yield
+      run_hook :"after_#{event}"
+      value
+    end
+
+    #
+    # Return logger instance
+    #
+    def log
+      return @log if @log
+      os = config[:log_file] ? File.open(config[:log_file], "a") : $stdout
+      os.sync = !!config[:log_flush]
+      @log = Logger.new(os)
+      @log.level = Logger.const_get(config[:log_level] ? config[:log_level].upcase : "INFO")
+      @log
+    end
+
+    #
+    # Configure bot
+    #
+    def configure
+      yield @config
+      @conf = nil
+      @twitter = nil
+    end
+
+   private
+    #
+    # Map configuration settings
+    #
+    def method_missing(name, *args, &block)
+      return super unless config.key?(name)
+
+      self.class.send(:define_method, name) { config[name] }
+      config[name]
+    end
+
+    #
+    # Return configuration
+    #
+    def config
+      return @conf if @conf
+      @conf = @config.to_hash
+
+      if prompt? && (!@conf[:login] || !@conf[:password])
+        # No need to rescue LoadError - if the gem is missing then config will
+        # be incomplete, something which will be detected elsewhere
+        begin
+          require 'highline'
+          hl = HighLine.new
+
+          @config.login = hl.ask("Twitter login: ") unless @conf[:login]
+          @config.password = hl.ask("Twitter password: ") { |q| q.echo = '*' } unless @conf[:password]
+          @conf = @config.to_hash
+        rescue LoadError
+          raise SystemExit.new( <<-HELP
+Unable to continue without login and password. Do one of the following:
+  1) Install the HighLine gem (gem install highline) to be prompted for credentials
+  2) Create a config/bot.yml with login: and password:
+  3) Put a configure { |conf| conf.login = "..." } block in your bot application
+  4) Run bot with --login and --password options
+          HELP
+          )
+        end
+      end
+
+      @conf
+    end
+
+    #
+    # Takes a block and executes it in a sandboxed network environment. It
+    # catches and logs most common network connectivity and timeout errors.
+    #
+    # The method takes an optional parameter. If set, this value will be
+    # returned in case an error was raised.
+    #
+    def sandbox(return_value = nil)
+      begin
+        return_value = yield
+      rescue Twitter::RESTError => e
+        log.error("Failed to connect to Twitter. It's likely down for a bit:")
+        log.error(e.to_s)
+      rescue Errno::ECONNRESET => e
+        log.error("Connection was reset")
+        log.error(e.to_s)
+      rescue Timeout::Error => e
+        log.error("Timeout")
+        log.error(e.to_s)
+      rescue EOFError => e
+        log.error(e.to_s)
+      rescue Errno::ETIMEDOUT => e
+        log.error("Timeout")
+        log.error(e.to_s)
+      rescue JSON::ParserError => e
+        log.error("JSON Parsing error")
+        log.error(e.to_s)
+      rescue OpenSSL::SSL::SSLError => e
+        log.error("SSL error")
+        log.error(e.to_s)
+      rescue SystemStackError => e
+        log.error(e.to_s)
+      end
+
+      return return_value
+    end
+  end
+end
+
+# Expose DSL
+include Twibot::Macros
+
+# Run bot if macros has been used
+at_exit do
+  raise $! if $!
+  @@bot.run! if run?
+end