irc_machine 0.0.1

data/.gitignore

@@ -0,0 +1,6 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+/log/
+/irc_machine.json

data/.rvmrc

@@ -0,0 +1 @@
+rvm @irc_machine --create

data/Gemfile

@@ -0,0 +1,2 @@
+source :rubygems
+gemspec

data/README.md

@@ -0,0 +1,56 @@
+IRC Machine
+===========
+
+An IRC bot with a RESTful HTTP interface, built on Ruby and [EventMachine](http://rubyeventmachine.com/).
+
+Design philosophy: simple to the point of under-engineered, make it work for the 90% case.
+
+    # something like this might work
+    git clone git://github.com/pda/irc_machine
+    cd irc_machine
+    cp example.json irc_machine.json
+
+    # run it
+    ./bin/irc_machined run
+    # ctrl+c
+
+    # daemonize it
+    ./bin/irc_machined start
+    # stop the daemon
+    ./bin/irc_machined stop
+
+    # or maybe even this (chances aren't good, though)
+    gem install irc_machine
+    irc_machined run
+
+
+HTTP interface
+--------------
+
+The RESTful HTTP API is provided by `IrcMachine::Plugin::Rest`. It listens on port 8421 by default. And you can't change the default.
+
+* `GET /channels` returns a JSON list of channels the bot is probably in.
+* `PUT /channels/{name}` joins a channel.
+* `DELETE /channels/{name}` parts a channel.
+* `POST /channels/{name}` sends a text/plain message to a channel, auto-joins if required.
+* `POST /channels/{name}/github` accepts GitHub post-receive hook notifications, notifies channel.
+
+
+Plugins
+-------
+
+Plugins are objects which might respond to `#start` or `#receive_line`, and might use a reference to the `IrcMachine::Session` instance to send IRC commands.
+
+
+Contributors
+------------
+
+* [Paul Annesley](https://github.com/pda)
+* [Eric Anderson](https://github.com/ericanderson)
+* [Anton Lindström](https://github.com/antonlindstrom)
+
+
+Meh.
+----
+
+© Paul Annesley, 2011, [MIT license](http://www.opensource.org/licenses/mit-license.php)

data/Rakefile

@@ -0,0 +1 @@
+require 'bundler/gem_tasks'

data/bin/irc_machine

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+$: << File.expand_path("../../lib", __FILE__)
+
+require 'irc_machine/cli_shared'
+
+IrcMachine::Session.new(IRC_MACHINE).start

data/bin/irc_machined

@@ -0,0 +1,26 @@
+#!/usr/bin/env ruby
+$: << File.expand_path("../../lib", __FILE__)
+
+require 'rubygems'
+require 'daemons'
+
+require 'irc_machine/cli_shared'
+
+daemon_defaults = {
+  :app_name => 'irc_machine',
+  :dir_mode => :normal,
+  :dir => ".",
+  :multiple => false,
+  :backtrace => true,
+  :monitor => false,
+  :log_dir => File.expand_path("../../log", __FILE__),
+  :log_output => true
+}
+
+IRC_MACHINE[:daemon] ||= {}
+
+daemon_params = daemon_defaults.merge(IRC_MACHINE[:daemon])
+
+FileUtils.mkdir_p(daemon_params[:log_dir])
+
+Daemons.run(File.expand_path("../irc_machine", __FILE__), daemon_params)

data/example.json

@@ -0,0 +1,13 @@
+{
+  "server": "localhost",
+	"port": 6667,
+	"nick": "im",
+	"user": "irc_machine",
+	"realname": "IRC Machine",
+	"channels": [ "#irc_machine", "#secret the_key" ],
+	"verbose": true,
+	"udp_port": 8421,
+	"http_port": 8421,
+	"bind_address": "127.0.0.1",
+	"ssl": false
+}

data/irc_machine.gemspec

@@ -0,0 +1,27 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "irc_machine/version"
+
+Gem::Specification.new do |s|
+  s.name        = "irc_machine"
+  s.version     = IrcMachine::VERSION
+  s.authors     = ["Paul Annesley"]
+  s.email       = ["paul@annesley.cc"]
+  s.homepage    = "https://github.com/pda/irc_machine"
+  s.summary     = %q{irc machine}
+  s.description = %q{An IRC bot using EventMachine, and perhaps ØMQ one day.}
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_dependency "eventmachine"
+  s.add_dependency "eventmachine_httpserver"
+  s.add_dependency "rack"
+  s.add_dependency "daemons"
+
+  s.add_development_dependency "bundler"
+  s.add_development_dependency "rake"
+
+end

data/lib/irc_machine.rb

@@ -0,0 +1,21 @@
+%w{
+  ostruct
+  eventmachine
+  evma_httpserver
+  evma_httpserver/response
+  rack
+}.each do |name|
+  require name
+end
+
+%w{
+  commands
+  irc_connection
+  session
+  state
+  plugin
+  plugin/base
+  plugin/reloader
+}.each do |name|
+  require "irc_machine/#{name}"
+end

data/lib/irc_machine/cli_shared.rb

@@ -0,0 +1,6 @@
+require "json"
+require 'irc_machine/monkey_patches'
+require 'irc_machine'
+
+ENV['IRC_MACHINE_CONF'] ||= File.expand_path("./irc_machine.json")
+IRC_MACHINE = JSON.load(open(ENV['IRC_MACHINE_CONF'])).symbolize_keys

data/lib/irc_machine/commands.rb

@@ -0,0 +1,38 @@
+module IrcMachine
+  module Commands
+
+    def raw(raw)
+      puts ">> #{raw}"
+      irc_connection.send_data "#{raw}\r\n"
+    end
+
+    def user(user, name)
+      raw "USER #{user} 8 * :#{name}"
+    end
+
+    def password(password)
+      raw "PASS #{password}"
+    end
+
+    def nick(nick)
+      raw "NICK #{nick}"
+    end
+
+    def join(channel, key = nil)
+      raw "JOIN #{channel}".tap { |c| c << " #{key}" if key }
+    end
+
+    def part(channel)
+      raw "PART #{channel}"
+    end
+
+    def quit(reason)
+      raw "QUIT :#{reason}"
+    end
+
+    def msg(to, text)
+      raw "PRIVMSG #{to} :#{text}"
+    end
+
+  end
+end

data/lib/irc_machine/controller/channels_controller.rb

@@ -0,0 +1,32 @@
+module IrcMachine
+  module Controller
+    class ChannelsController < HttpController
+
+      def list
+        content_type "application/json"
+        ok session.state.channels.to_json << "\n"
+      end
+
+      def join
+        session.join channel(match), request.GET["key"]
+      end
+
+      def part
+        session.part channel(match)
+      end
+
+      def message
+        input = request.body.gets
+        source = request.env["HTTP_X_AUTH"] || request.ip || "unknown"
+        session.msg channel(match), "[#{source}] #{input.chomp}" if input
+      end
+
+      private
+
+      def channel(match)
+        "#" + match[1]
+      end
+
+    end
+  end
+end

data/lib/irc_machine/controller/github_notifications_controller.rb

@@ -0,0 +1,12 @@
+module IrcMachine
+  module Controller
+    class GithubNotificationsController < HttpController
+
+      def notify
+        session.msg "##{match[1]}",
+          Plugin::GithubNotification.new(request.body.read).message
+      end
+
+    end
+  end
+end

data/lib/irc_machine/core.rb

@@ -0,0 +1,54 @@
+module IrcMachine
+  class Core < Plugin::Base
+
+    def connected
+      session.password options.password unless options.password.nil?
+      session.user options.user, options.realname
+      session.nick options.nick
+      session.state.nick = options.nick
+      EM::add_timer(5) do
+        options.channels.each { |c| session.join *c.split } if options.channels
+      end
+    end
+
+    def terminate
+      session.quit "shutting down"
+    end
+
+    def receive_line(line)
+
+      puts "[core] << #{line}" if options.verbose
+
+      case line
+
+      when /^PING (.*)/
+        session.raw "PONG #{$1}"
+
+      when /^:#{self_pattern} JOIN :(\S+)/
+        channels << $1
+
+      when /^:#{self_pattern} PART :(\S+)/
+        channels.delete $1
+
+      when /^:\S+ 475 \S+ (\S+) :(.*)$/
+        puts "[core] #{$1}: #{$2}"
+
+      end
+    end
+
+    private
+
+    def options
+      session.options
+    end
+
+    def self_pattern
+      Regexp.escape(session.state.nick) + '!\S+@\S+'
+    end
+
+    def channels
+      session.state.channels
+    end
+
+  end
+end

data/lib/irc_machine/core_routes.rb

@@ -0,0 +1,16 @@
+module IrcMachine
+  module CoreRoutes
+
+    CHANNEL_REGEXP ||= %r{^/channels/([\w-]+)$}
+
+    def draw_routes
+      get "/channels", "ChannelsController#list"
+      put CHANNEL_REGEXP, "ChannelsController#join"
+      delete CHANNEL_REGEXP, "ChannelsController#part"
+      post CHANNEL_REGEXP, "ChannelsController#message"
+
+      post %r{^/channels/([\w-]+)/github$}, "GithubNotificationsController#notify"
+    end
+
+  end
+end

data/lib/irc_machine/http_controller.rb

@@ -0,0 +1,35 @@
+module IrcMachine
+  class HttpController
+
+    def self.dispatch(session, request, method, match)
+      new(session, request, match).tap do |c|
+        c.send method
+      end.response
+    end
+
+    def initialize(session, request, match)
+      @session = session
+      @request = request
+      @match = match
+      @response = Rack::Response.new
+    end
+
+    attr_reader :session
+    attr_reader :request, :response
+    attr_reader :match
+
+    def ok(content)
+      @response.status = 200
+      @response.write content
+    end
+
+    def not_found
+      @response.status = 404
+    end
+
+    def content_type(type)
+      @response["Content-Type"] = type
+    end
+
+  end
+end

data/lib/irc_machine/http_router.rb

@@ -0,0 +1,66 @@
+require "evma_httpserver/response"
+require "stringio"
+
+module IrcMachine
+  class HttpRouter
+
+    include CoreRoutes
+
+    def initialize(session)
+      @session = session
+      @routes = { get: [], put: [], delete:[], post: [] }
+      draw_routes
+    end
+
+    def route(env)
+      request = Rack::Request.new(env)
+
+      match = lookup_route_match(request.request_method, request.path)
+
+      puts "%s %s %s => %s" % [
+        self.class,
+        request.request_method,
+        request.path,
+        match.destination.inspect
+      ]
+
+      response = case match.destination
+      when String
+        name, method = match.destination.split("#")
+        klass = IrcMachine::Controller.const_get(name)
+        klass.dispatch(@session, request, method, match.match)
+      else
+        Rack::Response.new "Unhandled destination: #{match.destination.class}", 500
+      end
+
+      response.finish
+    end
+
+    def get(route, destination); connect :get, route, destination; end
+    def put(route, destination); connect :put, route, destination; end
+    def delete(route, destination); connect :delete, route, destination; end
+    def post(route, destination); connect :post, route, destination; end
+
+    def connect(method, pattern, destination)
+      @routes[method] << [ pattern, destination ]
+    end
+
+    private
+
+    def lookup_route_match(request_method, path)
+      # this is pretty bad..
+      request_method = request_method.downcase.to_sym
+      route_match = OpenStruct.new
+      _, route_match.destination = @routes[request_method].detect do |(pattern,destination)|
+        if pattern.is_a? Regexp
+          route_match.match = pattern.match(path)
+        else
+          route_match.match = nil
+          pattern == path
+        end
+      end
+      route_match
+    end
+
+  end
+end

data/lib/irc_machine/http_server.rb

@@ -0,0 +1,74 @@
+require "socket"
+
+module IrcMachine
+
+  class HttpServer < EM::Connection
+
+    include EM::HttpServer
+
+    attr_accessor :router
+
+    def process_http_request
+      send_response(*router.route(rack_env))
+    rescue => e
+      puts "!! #{self.class} rescued #{e.inspect}"
+      puts "    " + e.backtrace.join("\n    ")
+      send_response 500, {}, [ e.inspect, "\n" ]
+    end
+
+    def send_response(status, headers, body)
+      EM::DelegatedHttpResponse.new(self).tap do |r|
+        r.status = status
+        r.headers = headers
+        # Rack body is only guaranteed to respond to #each
+        r.content = "".tap { |c| body.each { |b| c << b } }
+        r.send_response
+      end
+    end
+
+    def rack_env
+      # TODO: map headers to HTTP_... keys.
+      {
+        "rack.version" => [1, 1],
+        "rack.url_scheme" => @http_protocol,
+        "rack.input" => StringIO.new((@http_post_content || "")),
+        "rack.errors" => open("/dev/null", "w"), # muahaha
+        "rack.multithread" => false,
+        "rack.multiprocess" => false,
+        "rack.run_once" => false,
+
+        "REQUEST_METHOD" => @http_request_method,
+        "SCRIPT_NAME" => "", # see PATH_INFO
+        "PATH_INFO" => @http_path_info,
+        "QUERY_STRING" => @http_query_string,
+        "SERVER_NAME" => nil, # illegally nil
+        "SERVER_PORT" => nil, # illegally nil
+        "REMOTE_ADDR" => remote_ip, # not in spec
+
+        "HTTP_COOKIE" => @http_cookie,
+        "HTTP_IF_NONE_MATCH" => @http_if_none_match,
+        "HTTP_CONTENT_TYPE" => @http_content_type,
+        "HTTP_X_AUTH" => headers["X-Auth"],
+      }
+    end
+
+    def remote_ip
+      port, ip = Socket.unpack_sockaddr_in(get_peername)
+      ip
+    end
+
+    def headers
+      @headers ||= parse_headers(@http_headers)
+    end
+
+    # ghetto
+    def parse_headers(header)
+      header.split("\x00").inject({}) do |headers, line|
+        headers[$1] = $2 if line =~ /^([^:]+):\s*(.*)$/
+        headers
+      end
+    end
+
+  end
+
+end

data/lib/irc_machine/irc_connection.rb

@@ -0,0 +1,50 @@
+module IrcMachine
+  class IrcConnection < EM::Connection
+    include EM::Protocols::LineText2
+
+    def initialize(opts)
+      @ssl = opts[:ssl]
+      @session = opts[:session]
+    end
+
+    alias_method :orig_post_init, :post_init
+
+    def post_init
+      if @ssl
+        @session.log "Initializing SSL connection"
+        @ssl_buffer = ""
+        start_tls
+      else
+        orig_post_init
+      end
+    end
+
+    def ssl_handshake_completed
+      @session.log "SSL handshake complete"
+      orig_post_init
+      buffer = @ssl_buffer
+      @ssl_buffer = nil
+      send_data buffer
+    end
+
+    def send_data(data)
+      if @ssl_buffer
+        @ssl_buffer << data
+      else
+        super(data)
+      end
+    end
+
+    def receive_line(line)
+      @session.receive_line(line)
+    rescue => e
+      @session.log "!! #{self.class} rescued #{e.inspect}"
+      @session.log("    " + e.backtrace.join("\n    "))
+    end
+
+    def unbind
+      @session.log "Disconnected"
+      @session.disconnected
+    end
+  end
+end

data/lib/irc_machine/monkey_patches.rb

@@ -0,0 +1,13 @@
+class Hash
+  def symbolize_keys
+    inject({}) do |h, (k,v)|
+      h[k.to_sym] = case v
+                    when Hash
+                      v.symbolize_keys
+                    else
+                      v
+                    end
+      h
+    end
+  end
+end

data/lib/irc_machine/plugin.rb

@@ -0,0 +1,4 @@
+module IrcMachine
+  module Plugin
+  end
+end

data/lib/irc_machine/plugin/base.rb

@@ -0,0 +1,10 @@
+module IrcMachine
+  module Plugin
+    class Base
+      def initialize(session)
+        @session = session
+      end
+      attr_reader :session
+    end
+  end
+end

data/lib/irc_machine/plugin/github_notifier.rb

@@ -0,0 +1,58 @@
+require "json"
+require "cgi"
+require "ostruct"
+
+module IrcMachine
+  module Plugin
+
+    class GithubNotifier < Plugin::Base
+    end
+
+    class GithubNotification
+
+      attr_reader :data
+
+      def initialize(body)
+        json = CGI.parse(body)["payload"][0]
+        @data = OpenStruct.new(JSON.parse(json))
+      end
+
+      def repo_name
+        data.repository["name"]
+      end
+
+      def commit_count
+        data.commits.size
+      end
+
+      def branch
+        data.ref.split("/").last
+      end
+
+      def authors
+        data.commits.map{ |c| OpenStruct.new c["author"] }
+      end
+
+      def author_usernames
+        authors.map{ |a| a.username }.uniq
+      end
+
+      def compare_url
+        data.compare
+      end
+
+      def message
+        "%d commit%s by %s pushed to %s/%s: %s" % [
+          commit_count,
+          commit_count == 1 ? "" : "s",
+          author_usernames.join(", "),
+          repo_name,
+          branch,
+          compare_url
+        ]
+      end
+
+    end
+
+  end
+end

data/lib/irc_machine/plugin/hello.rb

@@ -0,0 +1,7 @@
+class IrcMachine::Plugin::Hello < IrcMachine::Plugin::Base
+  def receive_line(line)
+    if line =~ /^:\S+ PRIVMSG (#+\S+) :hello$/
+      session.msg $1, "world"
+    end
+  end
+end

data/lib/irc_machine/plugin/reloader.rb

@@ -0,0 +1,33 @@
+class IrcMachine::Plugin::Reloader < IrcMachine::Plugin::Base
+
+  def receive_line(line)
+    if line =~ /^:\S+ PRIVMSG #{session.state.nick} :reload$/
+      self.class.load_all
+    end
+  end
+
+  def self.load_all
+    files = %w{
+      core
+      core_routes
+
+      udp_server
+
+      http_controller
+      http_router
+      http_server
+
+      controller/channels_controller
+      controller/github_notifications_controller
+
+      plugin/github_notifier
+      plugin/base
+      plugin/hello
+      plugin/reloader
+    }.each do |name|
+      puts "loading: #{name}"
+      load "irc_machine/#{name}.rb"
+    end
+  end
+
+end

data/lib/irc_machine/session.rb

@@ -0,0 +1,97 @@
+module IrcMachine
+  class Session
+    include Commands
+
+    attr_reader :options
+    attr_reader :state
+    attr_accessor :irc_connection
+
+    def initialize(options)
+      IrcMachine::Plugin::Reloader.load_all
+
+      @options = OpenStruct.new(options)
+      @state = State.new
+      @router = HttpRouter.new(self)
+      @plugins = [
+        Core.new(self),
+        Plugin::Hello.new(self),
+        Plugin::Reloader.new(self),
+        Plugin::GithubNotifier.new(self)
+      ]
+    end
+
+    def start
+      EM.run do
+
+        signal_traps
+
+        log "Connecting to #{options.server}:#{options.port}"
+        EM.connect(
+          options.server,
+          options.port,
+          IrcConnection,
+          {:ssl => @options.ssl, :session => self}
+        ) do |c|
+          self.irc_connection = c
+        end
+
+        log "Starting HTTP API on port #{options.http_port}"
+        EM.start_server "0.0.0.0", options.http_port, HttpServer do |c|
+          c.router = @router
+        end
+
+        log "Starting UDP API on port #{options.udp_port}"
+        EM.open_datagram_socket "0.0.0.0", options.udp_port, UdpServer do |c|
+          c.session = self
+        end
+
+        dispatch :connected
+      end
+    end
+
+    def disconnected
+      if @shutdown
+        log "Stopping EventMachine"
+        EM.stop
+      else
+        log "Waiting to reconnect"
+        EM.add_timer(2) do
+          log "Reconnecting to #{options.server}:#{options.port}"
+          irc_connection.reconnect options.server, options.port
+          @state.reset
+          dispatch :connected
+        end
+      end
+    end
+
+    def receive_line(line)
+      dispatch :receive_line, line
+    end
+
+    def log message
+      puts "! " << message if options.verbose
+    end
+
+    private
+
+    def dispatch(method, *params)
+      @plugins.each { |p| p.send(method, *params) if p.respond_to? method }
+    end
+
+    def signal_traps
+      Signal.trap("INT") { shutdown }
+    end
+
+    def shutdown
+      @shutdown = true
+      Signal.trap("INT") do
+        Signal.trap("INT", "DEFAULT")
+        puts "\nStopping EventMachine, interrupt again to force exit"
+        EM.stop
+      end
+      puts "\nQuitting IRC, interrupt again to stop EventMachine"
+      dispatch :terminate
+    end
+
+  end
+end

data/lib/irc_machine/state.rb

@@ -0,0 +1,21 @@
+module IrcMachine
+  class State
+
+    attr_accessor :nick
+    attr_accessor :channels
+
+    def initialize
+      reset
+    end
+
+    def reset
+      @nick = nil
+      @channels = []
+    end
+
+    def channel?(channel)
+      channels.include? channel
+    end
+
+  end
+end

data/lib/irc_machine/udp_server.rb

@@ -0,0 +1,20 @@
+module IrcMachine
+
+  class UdpServer < EM::Connection
+
+    attr_writer :session
+
+    def receive_data(data)
+      if data =~ /^PRIVMSG (#+\S+) :(.{1,1024})/
+        @session.msg $1, $2
+      else
+        puts "Unrecognized UDP: " << data.inspect
+      end
+    rescue => e
+      puts "!! #{self.class} rescued #{e.inspect}"
+      puts "    " + e.backtrace.join("\n    ")
+    end
+
+  end
+
+end

data/lib/irc_machine/version.rb

@@ -0,0 +1,3 @@
+module IrcMachine
+  VERSION = "0.0.1"
+end

metadata

@@ -0,0 +1,144 @@
+--- !ruby/object:Gem::Specification
+name: irc_machine
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Paul Annesley
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-04-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: eventmachine
+  requirement: &70147236217340 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70147236217340
+- !ruby/object:Gem::Dependency
+  name: eventmachine_httpserver
+  requirement: &70147236216920 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70147236216920
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: &70147236216500 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70147236216500
+- !ruby/object:Gem::Dependency
+  name: daemons
+  requirement: &70147236216080 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70147236216080
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: &70147236215660 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70147236215660
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &70147236215240 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70147236215240
+description: An IRC bot using EventMachine, and perhaps ØMQ one day.
+email:
+- paul@annesley.cc
+executables:
+- irc_machine
+- irc_machined
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rvmrc
+- Gemfile
+- README.md
+- Rakefile
+- bin/irc_machine
+- bin/irc_machined
+- example.json
+- irc_machine.gemspec
+- lib/irc_machine.rb
+- lib/irc_machine/cli_shared.rb
+- lib/irc_machine/commands.rb
+- lib/irc_machine/controller/channels_controller.rb
+- lib/irc_machine/controller/github_notifications_controller.rb
+- lib/irc_machine/core.rb
+- lib/irc_machine/core_routes.rb
+- lib/irc_machine/http_controller.rb
+- lib/irc_machine/http_router.rb
+- lib/irc_machine/http_server.rb
+- lib/irc_machine/irc_connection.rb
+- lib/irc_machine/monkey_patches.rb
+- lib/irc_machine/plugin.rb
+- lib/irc_machine/plugin/base.rb
+- lib/irc_machine/plugin/github_notifier.rb
+- lib/irc_machine/plugin/hello.rb
+- lib/irc_machine/plugin/reloader.rb
+- lib/irc_machine/session.rb
+- lib/irc_machine/state.rb
+- lib/irc_machine/udp_server.rb
+- lib/irc_machine/version.rb
+homepage: https://github.com/pda/irc_machine
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.11
+signing_key: 
+specification_version: 3
+summary: irc machine
+test_files: []
+has_rdoc: