shin-irc_cat 0.4.0

data/bin/icat

@@ -0,0 +1,54 @@
+#!/usr/bin/env ruby
+#
+# `cat` for irccat :)
+#
+#  Created on 2008-2-17.
+#  Copyright (c) 2008. All rights reserved.
+
+require 'optparse'
+require 'yaml'
+
+OPTIONS = {
+  :profile     => 'default'
+}
+MANDATORY_OPTIONS = %w(  )
+
+parser = OptionParser.new do |opts|
+  opts.banner = <<BANNER
+icat - just like cat but for irccat
+
+Usage: #{File.basename($0)} [options] <files or STDIN>
+
+Options are:
+BANNER
+  opts.separator ""
+  opts.on("-p", "--profile=PROFILE", String,
+          "Profile to use (in ~/.irccat.yml).",
+          "Default: 'default'") { |OPTIONS[:profile]| }
+  opts.on("-h", "--help",
+          "Show this help message.") { puts opts; exit }
+  opts.parse!(ARGV)
+
+  if MANDATORY_OPTIONS && MANDATORY_OPTIONS.find { |option| OPTIONS[option.to_sym].nil? }
+    puts opts; exit
+  end
+end
+
+raise "Can't read configuration file (~/.irccat.yml)" unless File.exists?(File.expand_path("~/.irccat.yml"))
+@config = YAML.load_file(File.expand_path("~/.irccat.yml"))
+
+@profile = @config["#{OPTIONS[:profile]}"]
+raise "Can't find profile #{OPTIONS[:profile]} in ~/.irccat.yml" if @profile.nil?
+
+require File.dirname(__FILE__) + '/../lib/irc_cat/tcp_client'
+
+if ARGV.empty?
+  puts "has stdin"
+  message = STDIN.read
+  IrcCat::TcpClient.notify(@profile['host'], @profile['port'], message)
+else
+  ARGV.each do |file|
+    raise "Can't read #{file}" unless File.exists?(File.expand_path(file))
+    IrcCat::TcpClient.notify(@profile['host'], @profile['port'], File.read(File.expand_path(file)))
+  end
+end

data/bin/iecho

@@ -0,0 +1,49 @@
+#!/usr/bin/env ruby
+#
+# `echo` for irccat :)
+#
+#  Created on 2008-2-17.
+#  Copyright (c) 2008. All rights reserved.
+
+require 'optparse'
+require 'yaml'
+
+OPTIONS = {
+  :profile     => 'default'
+}
+MANDATORY_OPTIONS = %w(  )
+
+parser = OptionParser.new do |opts|
+  opts.banner = <<BANNER
+iecho - just like echo but for irccat
+
+Usage: #{File.basename($0)} [options] text
+
+Options are:
+BANNER
+  opts.separator ""
+  opts.on("-p", "--profile=PROFILE", String,
+          "Profile to use (in ~/.irccat.yml).",
+          "Default: 'default'") { |OPTIONS[:profile]| }
+  opts.on("-h", "--help",
+          "Show this help message.") { puts opts; exit }
+  opts.parse!(ARGV)
+
+  if MANDATORY_OPTIONS && MANDATORY_OPTIONS.find { |option| OPTIONS[option.to_sym].nil? }
+    puts opts; exit
+  end
+end
+
+raise "Can't read configuration file (~/.irccat.yml)" unless File.exists?(File.expand_path("~/.irccat.yml"))
+@config = YAML.load_file(File.expand_path("~/.irccat.yml"))
+
+@profile = @config["#{OPTIONS[:profile]}"]
+raise "Can't find profile #{OPTIONS[:profile]} in ~/.irccat.yml" if @profile.nil?
+
+raise "Nothing to send" if ARGV.empty?
+
+require File.dirname(__FILE__) + '/../lib/irc_cat/tcp_client'
+
+message = ARGV.join(' ')
+
+IrcCat::TcpClient.notify(@profile['host'], @profile['port'], message)

data/bin/irccat

@@ -0,0 +1,66 @@
+#!/usr/bin/env ruby
+#
+#  Created on 2008-2-17.
+#  Copyright (c) 2008. All rights reserved.
+
+require 'optparse'
+require 'yaml'
+
+options = {
+  :config_filename => './config.yml'
+}
+
+parser = OptionParser.new do |opts|
+  opts.banner = <<BANNER
+irc_cat - stdout for irc
+
+Usage: #{File.basename($0)} [options]
+
+Options are:
+BANNER
+
+  opts.separator ""
+
+  opts.on("-c", "--config=CONFIG", String, "Path to the config file.", "Default: ./config.yml") do |filename|
+    options[:config_filename] = filename
+  end
+
+  opts.on("-h", "--help", "Show this help message.") {
+    puts opts
+    exit
+  }
+end
+
+parser.parse!(ARGV)
+
+raise "Can't read configuration file (#{options[:config_filename]})" unless File.exists?(options[:config_filename])
+config = YAML.load_file(options[:config_filename])
+
+lib_dir = File.dirname(__FILE__) + '/../lib/'
+require lib_dir + '/irc_cat'
+
+threads = []
+puts "irccat #{IrcCat::VERSION::STRING} (http://irccat.rubyforge.org/)"
+
+Thread.abort_on_exception = true
+
+irc_config = config['irc']
+IrcCat::Bot.run(irc_config['host'], irc_config['port'], irc_config['nick'], irc_config['pass']) do |bot|
+  puts "Connecting..."
+  irc_config['channels'].each do |channel|
+    name, pass = channel.split(" ")
+    bot.join_channel(name, pass)
+  end
+
+  tcp_config = config['tcp']
+  if tcp_config['enabled']
+    require lib_dir + 'irc_cat/tcp_server'
+    IrcCat::TcpServer.run(bot, tcp_config)
+  end
+
+  http_config = config['http']
+  if http_config['enabled']
+    require lib_dir + 'irc_cat/http_server'
+    IrcCat::HttpServer.run(bot, http_config)
+  end
+end

data/bin/irccat-config

@@ -0,0 +1,67 @@
+#!/usr/bin/env ruby
+#
+# Configuration generator for irccat
+#
+#  Created on 2008-2-17.
+#  Copyright (c) 2008. All rights reserved.
+
+require 'rubygems'
+require 'optparse'
+require 'yaml'
+require 'highline/import'
+
+def irccat_config
+  config = Hash.new
+  puts "== IRC Configuration"
+  config['irc'] = Hash.new
+  config['irc']['host'] = ask("Hostname:  ") { |q| q.default = "irc.freenode.net" }
+  config['irc']['port'] = ask("Port:  ") { |q| q.default = "6667" }
+  config['irc']['nick'] = ask("Nickname:  ") { |q| q.default = "irc_cat" }
+  config['irc']['channel'] = ask("Channel:  ") { |q| q.default = "#irc_cat" }
+  puts "\n== HTTP Configuration"
+  config['http'] = Hash.new
+  if agree("Enable HTTP?  ", true); config['http']['enabled'] = true; else; config['http']['enabled'] = false; end
+  if config['http']['enabled']
+    config['http']['host'] = ask("Hostname:  ") { |q| q.default = "0.0.0.0" }
+    config['http']['port'] = ask("Port:  ") { |q| q.default = "3489" }
+    if agree("Enable Basic HTTP send?  ", true); config['http']['send'] = true; else; config['http']['send'] = false; end
+    if agree("Enable Github?  ", true); config['http']['github'] = true; else; config['http']['github'] = false; end
+  end
+  puts "\n== TCP Configuration"
+  config['tcp'] = Hash.new
+  if agree("Enable TCP?  ", true); config['tcp']['enabled'] = true; else; config['tcp']['enabled'] = false; end
+  if config['tcp']['enabled']
+    config['tcp']['host'] = ask("Hostname:  ") { |q| q.default = "0.0.0.0" }
+    config['tcp']['port'] = ask("Port:  ") { |q| q.default = "5678" }
+    config['tcp']['size'] = ask("Socket size:  ") { |q| q.default = "400" }
+  end
+  puts "\n== Final steps"
+  file = ask("Configuration filename:  ") { |q| q.default = "config.yml" }
+  puts "Warning: File exists! If you choose yes now the file will be overwritten" if File.exists?(File.expand_path(file))
+  if agree("Write configuration file?  ", true)
+    File.open(File.expand_path(file), "w") { |yfile| YAML.dump(config, yfile) }
+  else
+    exit
+  end
+end
+
+def help
+  puts "irccat-config - configuration generator for irccat\n"
+  puts "Usage: #{File.basename($0)} irccat|client > configfile.yml"
+  exit 0
+end
+
+if ARGV[0].nil?
+  help
+else
+  case ARGV[0]
+  when 'irccat'
+    irccat_config
+  when 'client'
+    #client_config
+    # TODO: todo :D
+    help
+  else
+    help
+  end
+end

data/lib/irc_cat.rb

@@ -0,0 +1,9 @@
+require 'socket'
+require 'rack'
+require 'json'
+
+current_dir = File.dirname(__FILE__)
+
+require current_dir + '/irc_cat/version'
+require current_dir + '/irc_cat/indifferent_access'
+require current_dir + '/irc_cat/bot'

data/lib/irc_cat/bot.rb

@@ -0,0 +1,148 @@
+# This is the bot.
+# Original code by Madx (yapok.org)
+
+module IrcCat
+  class Bot
+    def self.run(host, port, nick, nick_pass = nil, &block)
+      new(host, port, nick, nick_pass, &block).run
+    end
+
+    def initialize(host, port, nick, nick_pass, &block)
+      @host, @port, @nick, @nick_pass = host, port, nick, nick_pass
+      @online, @connect_block = false, block
+
+      @realname = "irccat v#{VERSION::STRING}"
+      @refresh_rate = 10
+      @channels = {}
+
+      puts "Connecting to IRC #{@host}:#{@port}"
+    end
+
+    def online?
+      @online
+    end
+
+    def run(&block)
+      @socket = TCPSocket.open(@host, @port)
+      login
+
+      trap(:INT) {
+        puts "Bye bye."
+        sexit('God^WConsole killed me')
+        sleep 1
+        @socket.close
+        exit
+      }
+
+      threads = []
+
+      threads << Thread.new {
+        begin
+          while line = @socket.gets do
+            # Remove all formatting
+            line.gsub!(/[\x02\x1f\x16\x0f]/,'')
+            # Remove CTCP ASCII
+            line.gsub!(/\001/,'')
+            # Send to event handler
+            handle line
+            # Handle Pings from Server
+            sendln "PONG #{$1}" if /^PING\s(.*)/ =~ line
+          end
+        rescue EOFError
+          err 'Server Reset Connection'
+        rescue Exception => e
+          err e
+        end
+      }
+      threads << Thread.new {
+      }
+      threads.each { |th| th.join }
+    end
+
+    # Announces states
+    def announce(msg)
+      @channels.each do |channel,key|
+        say(channel, msg)
+      end
+    end
+
+    # Say something funkeh
+    def say(chan, msg)
+      sendln "PRIVMSG #{chan} :#{msg}"
+    end
+
+    def topic(chan, msg)
+      sendln "TOPIC #{chan} :#{msg}"
+    end
+
+    # Send EXIT
+    def sexit(message = 'quit')
+      sendln "QUIT :#{message}"
+    end
+
+    # Sends a message to the server
+
+    def sendln(cmd)
+      puts "Send: #{cmd}"
+      if cmd.size <= 510
+        @socket.write("#{cmd}\r\n")
+        STDOUT.flush
+      else
+      end
+    end
+
+    # Handle a received message
+
+    def handle(line)
+      puts "Got: #{line}"
+      case line
+      when /^:.+\s376/
+        puts "We're online"
+        @online = true
+        @connect_block.call(self) if @connect_block
+      when /^:.+KICK (#[^\s]+)/
+        auto_rejoin($1)
+      end
+    end
+
+    # Automatic events
+
+    def join_channel(channel, key)
+      @channels[channel] = key
+      $stdout.flush
+      if key
+        sendln "JOIN #{channel} #{key}"
+      else
+        sendln "JOIN #{channel}"
+      end
+    end
+
+    def auto_rejoin(channel)
+      join_channel(channel, @channels[channel])
+    end
+
+    def login
+      begin
+        sendln "NICK #{@nick}"
+        sendln "USER irc_cat . . :#{@realname}"
+        if @nick_pass
+          puts "logging in to NickServ"
+          sendln "PRIVMSG NICKSERV :identify #{@nick_pass}"
+        end
+      rescue Exception => e
+        err e
+      end
+    end
+
+    # Logging methods
+
+    def log(str)
+      $stdout.puts "DEBUG: #{str}"
+    end
+
+    def err(exception)
+      $stderr.puts "ERROR: #{exception}"
+      $stderr.puts "TRACE: #{exception.backtrace}"
+    end
+  end
+end

data/lib/irc_cat/http_server.rb

@@ -0,0 +1,125 @@
+module IrcCat
+  class HttpServer
+    class Unauthorized < StandardError; end
+    class BadRequest < StandardError; end
+
+    def self.run(bot, config)
+      new(bot, config).run
+    end
+
+    def initialize(bot, config)
+      @bot, @config = bot, config
+    end
+
+    def run
+      host, port = @config['host'], @config['port']
+      if handler = Rack::Handler.get(handler_name)
+        Thread.new {
+          handler.run(app, :Host => host, :Port => port)
+        }
+      else
+        raise "Could not find a valid Rack handler for #{handler_name.inspect}"
+      end
+    end
+
+    def handler_name
+      @config["server"] || "mongrel"
+    end
+
+    def app
+      endpoint = self
+      builder = Rack::Builder.new
+      if requires_auth?
+        builder.use Rack::Auth::Basic, "irccat" do |user,pass|
+          auth_user == user && auth_pass == pass
+        end
+      end
+      if prefix = @config["prefix"]
+        builder.map prefix do
+          run endpoint
+        end
+      else
+        builder.run endpoint
+      end
+      builder
+    end
+
+    def auth_user
+      @config["user"]
+    end
+
+    def auth_pass
+      @config["pass"]
+    end
+
+    def requires_auth?
+      if auth_user
+        if auth_pass
+          if auth_pass.empty?
+            raise "Empty HTTP password in config"
+          end
+          true
+        end
+      end
+    end
+
+    def call(env)
+      request = Rack::Request.new(env)
+
+      case request.path_info
+      when "/"
+        [200, {"Content-Type" => "text/plain"}, "OK"]
+      when "/topic"
+        message = request.params["message"]
+        if channel = request.params["channel"]
+          @bot.join_channel("##{channel}", request.params["key"])
+          @bot.topic("##{channel}", message)
+        else
+          raise "Need a channel"
+        end
+
+        [200, {"Content-Type" => "text/plain"}, "OK"]
+      when "/send"
+        raise "Send support is not enabled" unless @config["send"]
+
+        message = request.params["message"]
+        if channel = request.params["channel"]
+          @bot.join_channel("##{channel}", request.params["key"])
+          @bot.say("##{channel}", message)
+        elsif nick = request.params["nick"]
+          @bot.say(nick, message)
+        else
+          raise "Unknown action"
+        end
+
+        [200, {"Content-Type" => "text/plain"}, "OK"]
+      when "/github"
+        raise "GitHub support is not enabled" unless @config["github"]
+
+        data = JSON.parse(request.POST['payload'])
+
+        repository = data['repository']['name']
+        data['commits'].each do |commit|
+          topic = commit['message'].split("\n").first
+          ref =   commit['id'][0,7]
+          author = commit['author']['name']
+          @bot.announce "#{topic} - #{ref} - #{author}"
+        end
+
+        [200, {"Content-Type" => "text/plain"}, "OK"]
+      else
+        [404, {}, ""]
+      end
+    rescue Unauthorized
+      [401, {'WWW-Authenticate' => %(Basic realm="IrcCat")}, 'Authorization Required']
+    rescue BadRequest
+      [400, {}, 'Bad Request']
+    rescue Exception => e
+      puts "Got an error: #{e.class}, #{e.message}"
+      e.backtrace.each do |b|
+        puts "- #{b}"
+      end
+      [503, {}, "ERR"]
+    end
+  end
+end

data/lib/irc_cat/indifferent_access.rb

@@ -0,0 +1,75 @@
+# this class has dubious semantics and we only have it so that
+# people can write params[:key] instead of params['key']
+
+class HashWithIndifferentAccess < Hash
+  def initialize(constructor = {})
+    if constructor.is_a?(Hash)
+      super()
+      update(constructor)
+    else
+      super(constructor)
+    end
+  end
+
+  def default(key = nil)
+    if key.is_a?(Symbol) && include?(key = key.to_s)
+      self[key]
+    else
+      super
+    end
+  end
+
+  alias_method :regular_writer, :[]= unless method_defined?(:regular_writer)
+  alias_method :regular_update, :update unless method_defined?(:regular_update)
+
+  def []=(key, value)
+    regular_writer(convert_key(key), convert_value(value))
+  end
+
+  def update(other_hash)
+    other_hash.each_pair { |key, value| regular_writer(convert_key(key), convert_value(value)) }
+    self
+  end
+
+  alias_method :merge!, :update
+
+  def key?(key)
+    super(convert_key(key))
+  end
+
+  alias_method :include?, :key?
+  alias_method :has_key?, :key?
+  alias_method :member?, :key?
+
+  def fetch(key, *extras)
+    super(convert_key(key), *extras)
+  end
+
+  def values_at(*indices)
+    indices.collect {|key| self[convert_key(key)]}
+  end
+
+  def dup
+    HashWithIndifferentAccess.new(self)
+  end
+
+  def merge(hash)
+    self.dup.update(hash)
+  end
+
+  def delete(key)
+    super(convert_key(key))
+  end
+
+  def stringify_keys!; self end
+  def symbolize_keys!; self end
+
+  protected
+    def convert_key(key)
+      key.kind_of?(Symbol) ? key.to_s : key
+    end
+    def convert_value(value)
+      value.is_a?(Hash) ? value.with_indifferent_access : value
+    end
+end
+

data/lib/irc_cat/tcp_client.rb

@@ -0,0 +1,9 @@
+require 'socket'
+module IrcCat
+  class TcpClient
+    def self.notify(ip,port,message)
+      socket = TCPSocket.open(ip,port)
+      socket.write(message + "\r\n")
+    end
+  end
+end

data/lib/irc_cat/tcp_server.rb

@@ -0,0 +1,38 @@
+# The TCP Server
+module IrcCat
+  class TcpServer
+    def self.run(bot, config)
+      new(bot, config).run
+    end
+
+    def initialize(bot, config)
+      @bot, @config = bot, config
+    end
+
+    def run
+      Thread.new do
+        socket = TCPserver.new(ip, port)
+        puts "Starting TCP (#{ip}:#{port})"
+
+        loop do
+          Thread.start(socket.accept) do |s|
+            str = s.recv(@config['size'])
+            sstr = str.split(/\n/)
+            sstr.each do |l|
+              @bot.announce("#{l}")
+            end
+            s.close
+          end
+        end
+      end
+    end
+
+    def ip
+      @config["ip"] || '127.0.0.1'
+    end
+
+    def port
+      @config["port"] || '8080'
+    end
+  end
+end

data/lib/irc_cat/version.rb

@@ -0,0 +1,9 @@
+module IrcCat #:nodoc:
+  module VERSION #:nodoc:
+    MAJOR = 0
+    MINOR = 4
+    TINY  = 0
+
+    STRING = [MAJOR, MINOR, TINY].join('.')
+  end
+end

metadata

@@ -0,0 +1,93 @@
+--- !ruby/object:Gem::Specification 
+name: shin-irc_cat
+version: !ruby/object:Gem::Version 
+  version: 0.4.0
+platform: ruby
+authors: 
+- Jordan Bracco
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-02-21 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rack
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: json
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: rake
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: irccat is like `cat`, but here, the STDOUT is an IRC channel.
+email: jordan@bracco.name
+executables: 
+- icat
+- iecho
+- irccat
+- irccat-config
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/irc_cat/bot.rb
+- lib/irc_cat/http_server.rb
+- lib/irc_cat/indifferent_access.rb
+- lib/irc_cat/tcp_client.rb
+- lib/irc_cat/tcp_server.rb
+- lib/irc_cat/version.rb
+- lib/irc_cat.rb
+has_rdoc: true
+homepage: http://github.com/webs/irccat
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: irccat is like `cat`, but here, the STDOUT is an IRC channel.
+test_files: []
+