firetower 0.0.1

data/Rakefile

@@ -0,0 +1,30 @@
+
+begin
+  require 'bones'
+rescue LoadError
+  abort '### Please install the "bones" gem ###'
+end
+
+task :default => 'test:run'
+task 'gem:release' => 'test:run'
+
+Bones {
+  name  'firetower'
+  authors  'Avdi Grimm'
+  email    'avdi@avdi.org'
+  url      'http://github.com/avdi/firetower'
+
+  summary "A command-line interface to Campfire chats"
+
+  readme_file 'README.org'
+
+  depend_on 'twitter-stream',   '~> 0.1.6'
+  depend_on 'eventmachine',     '~> 0.12.10'
+  depend_on 'json',             '~> 1.4'
+  depend_on 'addressable',      '~> 2.1'
+  depend_on 'main',             '~> 4.2'
+  depend_on 'servolux',         '~> 0.9.4'
+  depend_on 'hookr',            '~> 1.0'
+  depend_on 'highline',         '~> 1.5'
+}
+

data/bin/firetower

@@ -0,0 +1,336 @@
+#!/usr/bin/env ruby
+
+require File.expand_path(
+    File.join(File.dirname(__FILE__), %w[.. lib firetower]))
+
+Main do
+  description <<-"END"
+    A command-line interface to Campfire chats.
+
+    #{program} provides two primary services: a command-line syntax for posting
+    messages and code pastes to a Campfire chat room; and a daemon which can
+    monitor any number of Campfire rooms on multiple accounts and take
+    configurable actions when chat room events occur. Both usage modes share a
+    common simple Ruby-based configuration file.
+  END
+
+  author 'Avdi Grimm <avdi@avdi.org>'
+
+  examples [
+    "#{program} setup",
+    "#{program} say 'hello, Campfire'",
+    "#{program} say subdomain=mycompany room='Watercooler' 'hello room'",
+    "echo 'hello, Campfire' | #{program} say",
+    "#{program} paste '2+2 => 4'",
+    "#{program} paste subdomain=mycompany room='Watercooler' 'foobar'",
+    "#{program} paste --from=sel",
+    "#{program} paste --from=clip",
+    "#{program} paste --from=file hello.rb",
+    "#{program} paste --from=stdin < hello.rb",
+    "#{program} start",
+    "#{program} stop"
+  ]
+
+  usage["CONFIGURATION"] = <<-"END"
+    #{program} is configured by editing the file
+    $HOME/.firetower/firetower.conf. The file consists of Ruby code which is
+    evaluated in the context of a Firetower::Session object. You can generate a
+    starter configuration by running '#{program} setup'.
+
+    In addition to setting up accounts and rooms and enabling plugins, the
+    config file can also be used to attach arbitrary event handlers to Campfire
+    events. For instance, the following code plays a sound when someone says
+    something in Campfire:
+
+      receive do |session, event|
+        if event['type'] == 'TextMessage'
+          system 'paplay ding.wav'
+        end
+      end
+
+    The event hooks are HookR events (http://hookr.rubyforge.org), so any number
+    of handlers can be stacked on a given event. And more advanced usage are
+    possible; for instance, you can attach a Listener object to receive all
+    types of events. In fact, this last is how plugins are implemented.
+  END
+
+  fattr(:config_path) { dir + 'firetower.conf'   }
+  fattr(:log_path)    { dir + 'firetower.log' }
+  fattr(:pid_path)    { dir + 'firetower.pid' }
+
+  logger_level ::Logger::INFO
+
+  option('dir') do
+    description "Where to find/put config, data, and log files"
+    default {
+      File.join(
+        ENV.fetch('HOME'){Etc.getpwnam(Etc.getlogin).dir},
+        '.firetower')
+    }
+    attr{|dir| Pathname(dir.value) }
+  end
+
+  mixin :address do
+    keyword :subdomain do
+      optional
+      attr
+    end
+    keyword :room_name do
+      optional
+      attr
+    end
+
+    def selected_room(session)
+      if params[:subdomain].given? && params[:room_name].given?
+        session.accounts[subdomain].rooms[room_name]
+      else
+        session.default_room
+      end
+    end
+  end
+
+  mode :say do
+    description "Say something in a campfire chat room"
+    mixin :address
+    argument :text do
+      optional
+      attr{|text| text.given? ? text.value : $stdin.read }
+    end
+
+    def run
+      with_session do |session|
+        room = selected_room(session)
+        room.account.say!(room.name, text)
+        # account = session.accounts[subdomain]
+        # account.say!(room_name, text)
+      end
+    end
+  end
+
+  mode :paste do
+    description "Paste a pre-formatted message from command line, STDIN,"\
+                " selection, clipboard, or file"
+    mixin :address
+
+    argument "text_or_filename" do
+      description "Text to paste or file to paste from"
+      optional
+      attr
+    end
+
+    option 'from' do
+      description "Source of text. One of: clip|sel|stdin|file|arg"
+      argument :required
+      validate{|from| %w[clip sel stdin file arg auto].include?(from)}
+      default 'auto'
+      attr
+    end
+
+    def run
+      with_session do |session|
+        room = selected_room(session)
+        room.account.paste!(room.name, text)
+      end
+    end
+
+    def text
+      source = case from
+               when 'auto' then
+                 if params['text_or_filename'].given?
+                   'arg'
+                 elsif !$stdin.tty?
+                   'stdin'
+                 else
+                   'clip'
+                 end
+               else
+                 from
+               end
+
+      case source
+      when 'arg'   then params['text_or_filename'].value
+      when 'sel'   then `xsel --primary`
+      when 'clip'  then `xsel --clipboard`
+      when 'file'  then File.read(params['text_or_filename'].value)
+      when 'stdin' then $stdin.read
+      else
+        raise "Unknown text source #{from}"
+      end
+    end
+  end
+
+  mode :rooms do
+    description "List rooms"
+    argument :subdomain do
+      optional
+      attr
+    end
+
+    def run
+      with_session do |session|
+        accounts = if params[:subdomain].given?
+                     [session.accounts[subdomain]]
+                   else
+                     session.accounts.values
+                   end
+        accounts.each do |account|
+          puts "#{account.subdomain}:"
+          account.rooms.keys.each do |room_name|
+            puts "\t#{room_name}"
+          end
+        end
+      end
+    end
+  end
+
+  mode :account do
+    description "Prefix for accont-related commands"
+    mode :list do
+      description "List accounts"
+
+      def run
+        with_session do |session|
+          session.accounts.values.each do |account|
+            puts account.subdomain
+          end
+        end
+      end
+    end
+  end
+
+  mode :start do
+    description "Start the listener daemon"
+
+    option 'detach' do
+      description "Controls whether the server process will daemonize"
+      optional
+      argument :required
+      default true
+      cast :bool
+      attr
+    end
+
+    def run
+      if detach
+        firetower_daemon.startup
+      else
+        logger ::Logger.new($stdout)
+        start_server(:logger => logger)
+      end
+      puts "Firetower is vigilantly scanning the treetops"
+    end
+  end
+
+  mode :stop do
+    description "Start the listener daemon"
+
+    def run
+      firetower_daemon.shutdown
+      puts "Firetower is no longer on duty"
+    end
+  end
+
+  mode :setup do
+    description "Configure Firetower for first use"
+
+    def run
+      require 'erb'
+      hl = HighLine.new
+      exit_failure unless !config_path.exist? || hl.ask(<<"EOS")
+A configuration already exists at #{config_path}. Are you sure you want to
+overwrite it?
+EOS
+      subdomain = hl.ask <<EOS
+What is your Campfire subdomain? If your Campfire address is
+http://mycompany.campfirenow.com, your subdomain is "mycompany" (without the
+quotes).
+EOS
+      token = hl.ask <<"EOS"
+Please enter your Campfire API token. You can find your token at
+http://#{subdomain}.campfirenow.com/member/edit
+EOS
+      use_ssl    = hl.agree("Use SSL when connecting to Campfire?")
+      rooms_url  = "http#{use_ssl ? '?' : ''}://#{subdomain}.campfirenow.com/rooms.json"
+      response   = open(rooms_url, :http_basic_authentication => [token, 'x']).read
+      room_list  = JSON.parse(response)['rooms']
+      room_names = []
+      catch(:done) do
+        loop do
+          hl.choose do |menu|
+            menu.prompt = "Choose a room to join at startup: "
+            room_list.each do |room|
+              menu.choice(room['name']){ room_names << room['name']}
+            end
+            menu.choice("Done"){ throw :done }
+          end
+        end
+      end
+      template_path = File.expand_path(
+        '../lib/firetower/firetower.conf.erb',
+        File.dirname(__FILE__))
+      template = ERB.new(File.read(template_path), nil, "<>")
+      configuration = template.result(binding)
+      hl.say "The following configuration will be written to #{config_path}:\n\n"
+      hl.say configuration.gsub(/^/, "    ")
+      exit_failure unless hl.agree("Write new configuration?")
+      config_path.open('w+') do |config_file|
+        config_file.write(configuration)
+      end
+      hl.say "#{program} is now configured!"
+    end
+  end
+
+  def run
+    help!
+  end
+
+  def firetower_daemon
+    Servolux::Daemon.new(
+      :name            => File.basename($PROGRAM_NAME),
+      :logger          => logger,
+      :log_file        => log_path.to_s,
+      :pid_file        => pid_path.to_s,
+      :startup_command => lambda { start_server })
+  end
+
+  def start_server(options={})
+    with_session(:server, options) do |session|
+      server = Firetower::Server.new(session,
+        {
+          :log_path => log_path,
+          :pid_path => pid_path
+        }.merge(options))
+      server.run
+    end
+  end
+
+  def with_session(kind=:command, options={})
+    session = Firetower::Session.new(kind, options)
+    if config_path.exist?
+      session.instance_eval(config_path.read, config_path.to_s, 1)
+    else
+      puts "Please run '#{program} setup' to configure #{program}"
+      exit_failure
+    end
+    session.execute_hook(:startup, session)
+    yield session
+    session.execute_hook(:shutdown, session)
+  end
+
+  def before_run
+    self.logger.level = ::Logger::INFO
+    load_plugins!
+    dir.mkpath
+  end
+
+  def load_plugins!
+    Gem.find_files('firetower/plugins/*/init_v1').each do |path|
+      path =~ %r{firetower/plugins/(.*)/}
+      debug "Loading plugin #{$1}"
+      load path
+    end
+  end
+end
+
+
+

data/example/bot.rb

@@ -0,0 +1,8 @@
+# Drop this in ~/.firetower/firetower.conf for a simple (and VERY UNSAFE!) demo
+# of a Campfire bot:
+
+receive do |session, event|
+  if event['type'] == 'TextMessage' && event['body'] =~ /^!eval (.*)$/
+    event.room.account.paste!(event.room.name, "Eval result:\n" + eval($1).to_s)
+  end
+end

data/lib/firetower.rb

@@ -0,0 +1,80 @@
+require 'twitter/json_stream'
+require 'json'
+require 'addressable/uri'
+require 'open-uri'
+require 'main'
+require 'net/http'
+require 'ostruct'
+require 'yaml'
+require 'net/https'
+require 'servolux'
+require 'hookr'
+require 'pathname'
+require 'English'
+require 'highline'
+
+module Firetower
+
+  # :stopdoc:
+  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 ||= File.read(path('version.txt')).strip
+  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, &block )
+    rv =  args.empty? ? LIBPATH : ::File.join(LIBPATH, args.flatten)
+    if block
+      begin
+        $LOAD_PATH.unshift LIBPATH
+        rv = block.call
+      ensure
+        $LOAD_PATH.shift
+      end
+    end
+    return rv
+  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, &block )
+    rv = args.empty? ? PATH : ::File.join(PATH, args.flatten)
+    if block
+      begin
+        $LOAD_PATH.unshift PATH
+        rv = block.call
+      ensure
+        $LOAD_PATH.shift
+      end
+    end
+    return rv
+  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 unless rb =~ /plugins/}
+  end
+
+end  # module Firetower
+
+$:.unshift(Firetower::LIBPATH)
+Firetower.require_all_libs_relative_to(__FILE__)
+