net-yail 1.0.0

data/lib/net/yail/output_api.rb

@@ -0,0 +1,134 @@
+module Net
+
+# All output APIs live here.  In most cases, an outgoing handler will get a
+# call, but will not be able to stop the socket output since that's sorta
+# an essential part of this whole library.
+module IRCOutputAPI
+  # Spits a raw string out to the server - in case a subclass wants to do
+  # something special on *all* output, please make all output go through this
+  # method.  Don't use puts manually.  I will kill violaters.  Legally
+  # speaking, that is.
+  def raw(line, report = true)
+    @socket.puts line
+    report "bot: '#{line}'" if report
+  end
+
+  # Calls :outgoing_privmsg handler, then sends a message (text) out to the
+  # given channel/user (target), and reports itself with the given string.
+  # This method shouldn't be called directly most of the time - just use msg,
+  # act, or ctcp.
+  #
+  # This is sort of the central message output - everything that's based on
+  # PRIVMSG (messages, actions, other ctcp) uses this.  Because these messages
+  # aren't insanely important, we actually buffer them instead of sending
+  # straight out to the channel.  The output thread has to deal with
+  # sending these out.
+  def privmsg(target, text, report_string)
+    handle(:outgoing_privmsg, target, text)
+
+    @privmsg_buffer_mutex.synchronize do
+      @privmsg_buffer[target] ||= Array.new
+      @privmsg_buffer[target].push([text, report_string])
+    end
+  end
+
+  # Calls :outgoing_msg handler, then privmsg to send the message out.  Could
+  # be used to send any privmsg, but you're betting off using act and ctcp
+  # shortcut methods for those types.  Target is a channel or username, text
+  # is the message.
+  def msg(target, text)
+    handle(:outgoing_msg, target, text)
+
+    report_string = @silent ? '' : "{#{target}} <#{@me}> #{text}"
+    privmsg(target, text, report_string)
+  end
+
+  # Calls :outgoing_ctcp handler, then sends CTCP to target channel or user
+  def ctcp(target, text)
+    handle(:outgoing_ctcp, target, text)
+
+    report_string = @silent ? '' :  "{#{target}}  [#{@me} #{text}]"
+    privmsg(target, "\001#{text}\001", report_string)
+  end
+
+  # Calls :outgoing_act handler, then ctcp to send a CTCP ACTION (text) to
+  # a given user or channel (target)
+  def act(target, text)
+    handle(:outgoing_act, target, text)
+
+    ctcp(target, "ACTION #{text}")
+  end
+
+  # Calls :outgoing_notice handler, then outputs raw NOTICE message
+  def notice(target, text)
+    handle(:outgoing_notice, target, text)
+
+    report "{#{target}} -#{@me}- #{text}" unless @silent
+    raw("NOTICE #{target} :#{text}", false)
+  end
+
+  # Calls :outgoing_ctcpreply handler, then uses notice method to send the
+  # CTCP text
+  def ctcpreply(target, text)
+    handle(:outgoing_ctcpreply, target, text)
+
+    report "{#{target}} [Reply: #{@me} #{text}]" unless @silent
+    notice(target, "\001#{text}\001")
+  end
+
+  # Calls :outgoing_mode handler, then mode to set mode(s) on a channel
+  # and possibly specific users (objects).  If modes and objects are blank,
+  # just sends a raw MODE query.
+  def mode(target, modes = '', objects = '')
+    handle(:outgoing_mode, target, modes, objects)
+
+    message = "MODE #{target}"
+    message += " #{modes}" unless modes.to_s.empty?
+    message += " #{objects}" unless objects.to_s.empty?
+    raw message
+  end
+
+  # Calls :outgoing_join handler and then raw JOIN message for a given channel
+  def join(target)
+    handle(:outgoing_join, target)
+
+    raw "JOIN #{target}"
+  end
+
+  # Calls :outgoing_part handler and then raw PART for leaving a given channel
+  # (with an optional message)
+  def part(target, text = '')
+    handle(:outgoing_part, target, text)
+
+    request = "PART #{target}";
+    request += " :#{text}" unless text.to_s.empty?
+    raw request
+  end
+
+  # Calls :outgoing_quit handler and then raw QUIT message with an optional
+  # reason
+  def quit(text = '')
+    handle(:outgoing_quit, text)
+
+    request = "QUIT";
+    request += " :#{text}" unless text.to_s.empty?
+    raw request
+  end
+
+  # Calls :outgoing_nick handler and then sends raw NICK message to change
+  # nickname.
+  def nick(new_nick)
+    handle(:outgoing_nick, new_nick)
+
+    raw "NICK :#{new_nick}"
+  end
+
+  def user(username, myaddress, address, realname)
+    handle(:outgoing_user, username, myaddress, address, realname)
+
+    raw "USER #{username} #{myaddress} #{address} :#{realname}"
+  end
+
+end
+
+end

metadata

@@ -0,0 +1,54 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.4
+specification_version: 1
+name: net-yail
+version: !ruby/object:Gem::Version 
+  version: 1.0.0
+date: 2008-06-28 00:00:00 -04:00
+summary: "Yet Another IRC Library: wrapper for IRC communications in Ruby."
+require_paths: 
+- lib
+email: yail<at>nerdbucket dot com
+homepage: 
+rubyforge_project: 
+description: 
+autorequire: net/yail
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: 
+- Jeremy Echols
+files: 
+- IRCBot.rb
+- lib/net/yail.rb
+- lib/net/yail/magic_events.rb
+- lib/net/yail/default_events.rb
+- lib/net/yail/output_api.rb
+- lib/net/yail/eventmap.yml
+- README
+test_files: []
+
+rdoc_options: 
+- --main
+- README
+extra_rdoc_files: 
+- README
+- IRCBot.rb
+executables: []
+
+extensions: []
+
+requirements: []
+
+dependencies: []
+