diff --git a/lib/exirc/channels.ex b/lib/exirc/channels.ex
index a96cb2e..b7a6d4c 100644
--- a/lib/exirc/channels.ex
+++ b/lib/exirc/channels.ex
@@ -1,230 +1,230 @@
defmodule ExIrc.Channels do
@moduledoc """
Responsible for managing channel state
"""
use Irc.Commands
import String, only: [downcase: 1]
defmodule Channel do
defstruct name: '',
topic: '',
users: [],
modes: '',
type: ''
end
@doc """
Initialize a new Channels data store
"""
def init() do
:gb_trees.empty()
end
##################
# Self JOIN/PART
##################
@doc """
Add a channel to the data store when joining a channel
"""
def join(channel_tree, channel_name) do
name = downcase(channel_name)
case :gb_trees.lookup(name, channel_tree) do
{:value, _} ->
channel_tree
:none ->
:gb_trees.insert(name, %Channel{name: name}, channel_tree)
end
end
@doc """
Remove a channel from the data store when leaving a channel
"""
def part(channel_tree, channel_name) do
name = downcase(channel_name)
case :gb_trees.lookup(name, channel_tree) do
{:value, _} ->
:gb_trees.delete(name, channel_tree)
:none ->
channel_tree
end
end
###########################
# Channel Modes/Attributes
###########################
@doc """
Update the topic for a tracked channel when it changes
"""
def set_topic(channel_tree, channel_name, topic) do
name = downcase(channel_name)
case :gb_trees.lookup(name, channel_tree) do
{:value, channel} ->
- :gb_trees.enter(name, %{channel | :topic => topic}, channel_tree)
+ :gb_trees.enter(name, %{channel | topic: topic}, channel_tree)
:none ->
channel_tree
end
end
@doc """
Update the type of a tracked channel when it changes
"""
def set_type(channel_tree, channel_name, channel_type) when is_binary(channel_type) do
set_type(channel_tree, channel_name, String.to_char_list(channel_type))
end
def set_type(channel_tree, channel_name, channel_type) do
name = downcase(channel_name)
case :gb_trees.lookup(name, channel_tree) do
{:value, channel} ->
type = case channel_type do
'@' -> :secret
'*' -> :private
'=' -> :public
end
- :gb_trees.enter(name, %{channel | :type => type}, channel_tree)
+ :gb_trees.enter(name, %{channel | type: type}, channel_tree)
:none ->
channel_tree
end
end
####################################
# Users JOIN/PART/AKAs(namechange)
####################################
@doc """
Add a user to a tracked channel when they join
"""
def user_join(channel_tree, channel_name, nick) when not is_list(nick) do
users_join(channel_tree, channel_name, [nick])
end
@doc """
Add multiple users to a tracked channel (used primarily in conjunction with the NAMES command)
"""
def users_join(channel_tree, channel_name, nicks) do
pnicks = strip_rank(nicks)
manipfn = fn(channel_nicks) -> :lists.usort(channel_nicks ++ pnicks) end
users_manip(channel_tree, channel_name, manipfn)
end
@doc """
Remove a user from a tracked channel when they leave
"""
def user_part(channel_tree, channel_name, nick) do
pnick = strip_rank([nick])
manipfn = fn(channel_nicks) -> :lists.usort(channel_nicks -- pnick) end
users_manip(channel_tree, channel_name, manipfn)
end
@doc """
Update the nick of a user in a tracked channel when they change their nick
"""
def user_rename(channel_tree, nick, new_nick) do
manipfn = fn(channel_nicks) ->
case Enum.member?(channel_nicks, nick) do
true -> [new_nick | channel_nicks -- [nick]] |> Enum.uniq |> Enum.sort
false -> channel_nicks
end
end
foldl = fn(channel_name, new_channel_tree) ->
name = downcase(channel_name)
users_manip(new_channel_tree, name, manipfn)
end
:lists.foldl(foldl, channel_tree, channels(channel_tree))
end
################
# Introspection
################
@doc """
Get a list of all currently tracked channels
"""
def channels(channel_tree) do
(for {channel_name, _chan} <- :gb_trees.to_list(channel_tree), do: channel_name) |> Enum.reverse
end
@doc """
Get a list of all users in a tracked channel
"""
def channel_users(channel_tree, channel_name) do
- get_attr(channel_tree, channel_name, fn(%Channel{:users => users}) -> users end) |> Enum.reverse
+ get_attr(channel_tree, channel_name, fn(%Channel{users: users}) -> users end) |> Enum.reverse
end
@doc """
Get the current topic for a tracked channel
"""
def channel_topic(channel_tree, channel_name) do
- case get_attr(channel_tree, channel_name, fn(%Channel{:topic => topic}) -> topic end) do
+ case get_attr(channel_tree, channel_name, fn(%Channel{topic: topic}) -> topic end) do
[] -> "No topic"
topic -> topic
end
end
@doc """
Get the type of a tracked channel
"""
def channel_type(channel_tree, channel_name) do
- case get_attr(channel_tree, channel_name, fn(%Channel{:type => type}) -> type end) do
+ case get_attr(channel_tree, channel_name, fn(%Channel{type: type}) -> type end) do
[] -> :unknown
type -> type
end
end
@doc """
Determine if a user is present in a tracked channel
"""
def channel_has_user?(channel_tree, channel_name, nick) do
- get_attr(channel_tree, channel_name, fn(%Channel{:users => users}) -> :lists.member(nick, users) end)
+ get_attr(channel_tree, channel_name, fn(%Channel{users: users}) -> :lists.member(nick, users) end)
end
@doc """
Get all channel data as a tuple of the channel name and a proplist of metadata.
Example Result:
[{"#testchannel", [users: ["userA", "userB"], topic: "Just a test channel.", type: :public] }]
"""
def to_proplist(channel_tree) do
for {channel_name, chan} <- :gb_trees.to_list(channel_tree) do
{channel_name, [users: chan.users, topic: chan.topic, type: chan.type]}
end |> Enum.reverse
end
####################
# Internal API
####################
defp users_manip(channel_tree, channel_name, manipfn) do
name = downcase(channel_name)
case :gb_trees.lookup(name, channel_tree) do
{:value, channel} ->
channel_list = manipfn.(channel.users)
- :gb_trees.enter(channel_name, %{channel | :users => channel_list}, channel_tree)
+ :gb_trees.enter(channel_name, %{channel | users: channel_list}, channel_tree)
:none ->
channel_tree
end
end
defp strip_rank(nicks) do
nicks |> Enum.map(fn(n) -> case n do
<< "@", nick :: binary >> -> nick
<< "+", nick :: binary >> -> nick
<< "%", nick :: binary >> -> nick
<< "&", nick :: binary >> -> nick
<< "~", nick :: binary >> -> nick
nick -> nick
end
end)
end
defp get_attr(channel_tree, channel_name, getfn) do
name = downcase(channel_name)
case :gb_trees.lookup(name, channel_tree) do
{:value, channel} -> getfn.(channel)
:none -> {:error, :no_such_channel}
end
end
end
diff --git a/lib/exirc/client.ex b/lib/exirc/client.ex
index 0bfaf37..0ef50cc 100644
--- a/lib/exirc/client.ex
+++ b/lib/exirc/client.ex
@@ -1,735 +1,735 @@
defmodule ExIrc.Client do
@moduledoc """
Maintains the state and behaviour for individual IRC client connections
"""
use Irc.Commands
use GenServer
import ExIrc.Logger
alias ExIrc.Channels
alias ExIrc.Utils
alias ExIrc.SenderInfo
alias ExIrc.Client.Transport
# Client internal state
defmodule ClientState do
defstruct event_handlers: [],
server: "localhost",
port: 6667,
socket: nil,
nick: "",
pass: "",
user: "",
name: "",
ssl?: false,
connected?: false,
logged_on?: false,
autoping: true,
channel_prefixes: "",
network: "",
user_prefixes: "",
login_time: "",
channels: [],
debug?: false
end
#################
# External API
#################
@doc """
Start a new IRC client process
Returns either {:ok, pid} or {:error, reason}
"""
@spec start!(options :: list() | nil) :: {:ok, pid} | {:error, term}
def start!(options \\ []) do
start_link(options)
end
@doc """
Start a new IRC client process.
Returns either {:ok, pid} or {:error, reason}
"""
@spec start_link(options :: list() | nil, process_opts :: list() | nil) :: {:ok, pid} | {:error, term}
def start_link(options \\ [], process_opts \\ []) do
GenServer.start_link(__MODULE__, options, process_opts)
end
@doc """
Stop the IRC client process
"""
@spec stop!(client :: pid) :: {:stop, :normal, :ok, ClientState.t}
def stop!(client) do
GenServer.call(client, :stop)
end
@doc """
Connect to a server with the provided server and port
Example:
Client.connect! pid, "localhost", 6667
"""
@spec connect!(client :: pid, server :: binary, port :: non_neg_integer, options :: list() | nil) :: :ok
def connect!(client, server, port, options \\ []) do
GenServer.call(client, {:connect, server, port, options, false}, :infinity)
end
@doc """
Connect to a server with the provided server and port via SSL
Example:
Client.connect! pid, "localhost", 6697
"""
@spec connect_ssl!(client :: pid, server :: binary, port :: non_neg_integer, options :: list() | nil) :: :ok
def connect_ssl!(client, server, port, options \\ []) do
GenServer.call(client, {:connect, server, port, options, true}, :infinity)
end
@doc """
Determine if the provided client process has an open connection to a server
"""
@spec is_connected?(client :: pid) :: true | false
def is_connected?(client) do
GenServer.call(client, :is_connected?)
end
@doc """
Logon to a server
Example:
Client.logon pid, "password", "mynick", "username", "My Name"
"""
@spec logon(client :: pid, pass :: binary, nick :: binary, user :: binary, name :: binary) :: :ok | {:error, :not_connected}
def logon(client, pass, nick, user, name) do
GenServer.call(client, {:logon, pass, nick, user, name}, :infinity)
end
@doc """
Determine if the provided client is logged on to a server
"""
@spec is_logged_on?(client :: pid) :: true | false
def is_logged_on?(client) do
GenServer.call(client, :is_logged_on?)
end
@doc """
Send a message to a nick or channel
Message types are:
:privmsg
:notice
:ctcp
"""
@spec msg(client :: pid, type :: atom, nick :: binary, msg :: binary) :: :ok | {:error, atom}
def msg(client, type, nick, msg) do
GenServer.call(client, {:msg, type, nick, msg}, :infinity)
end
@doc """
Send an action message, i.e. (/me slaps someone with a big trout)
"""
@spec me(client :: pid, channel :: binary, msg :: binary) :: :ok | {:error, atom}
def me(client, channel, msg) do
GenServer.call(client, {:me, channel, msg}, :infinity)
end
@doc """
Change the client's nick
"""
@spec nick(client :: pid, new_nick :: binary) :: :ok | {:error, atom}
def nick(client, new_nick) do
GenServer.call(client, {:nick, new_nick}, :infinity)
end
@doc """
Send a raw IRC command
"""
@spec cmd(client :: pid, raw_cmd :: binary) :: :ok | {:error, atom}
def cmd(client, raw_cmd) do
GenServer.call(client, {:cmd, raw_cmd})
end
@doc """
Join a channel, with an optional password
"""
@spec join(client :: pid, channel :: binary, key :: binary | nil) :: :ok | {:error, atom}
def join(client, channel, key \\ "") do
GenServer.call(client, {:join, channel, key}, :infinity)
end
@doc """
Leave a channel
"""
@spec part(client :: pid, channel :: binary) :: :ok | {:error, atom}
def part(client, channel) do
GenServer.call(client, {:part, channel}, :infinity)
end
@doc """
Kick a user from a channel
"""
@spec kick(client :: pid, channel :: binary, nick :: binary, message :: binary | nil) :: :ok | {:error, atom}
def kick(client, channel, nick, message \\ "") do
GenServer.call(client, {:kick, channel, nick, message}, :infinity)
end
@spec names(client :: pid, channel :: binary) :: :ok | {:error, atom}
def names(client, channel) do
GenServer.call(client, {:names, channel}, :infinity)
end
@doc """
Change mode for a user or channel
"""
@spec mode(client :: pid, channel_or_nick :: binary, flags :: binary, args :: binary | nil) :: :ok | {:error, atom}
def mode(client, channel_or_nick, flags, args \\ "") do
GenServer.call(client, {:mode, channel_or_nick, flags, args}, :infinity)
end
@doc """
Invite a user to a channel
"""
@spec invite(client :: pid, nick :: binary, channel :: binary) :: :ok | {:error, atom}
def invite(client, nick, channel) do
GenServer.call(client, {:invite, nick, channel}, :infinity)
end
@doc """
Quit the server, with an optional part message
"""
@spec quit(client :: pid, msg :: binary | nil) :: :ok | {:error, atom}
def quit(client, msg \\ "Leaving..") do
GenServer.call(client, {:quit, msg}, :infinity)
end
@doc """
Get details about each of the client's currently joined channels
"""
@spec channels(client :: pid) :: list(binary) | [] | {:error, atom}
def channels(client) do
GenServer.call(client, :channels)
end
@doc """
Get a list of users in the provided channel
"""
@spec channel_users(client :: pid, channel :: binary) :: list(binary) | [] | {:error, atom}
def channel_users(client, channel) do
GenServer.call(client, {:channel_users, channel})
end
@doc """
Get the topic of the provided channel
"""
@spec channel_topic(client :: pid, channel :: binary) :: binary | {:error, atom}
def channel_topic(client, channel) do
GenServer.call(client, {:channel_topic, channel})
end
@doc """
Get the channel type of the provided channel
"""
@spec channel_type(client :: pid, channel :: binary) :: atom | {:error, atom}
def channel_type(client, channel) do
GenServer.call(client, {:channel_type, channel})
end
@doc """
Determine if a nick is present in the provided channel
"""
@spec channel_has_user?(client :: pid, channel :: binary, nick :: binary) :: true | false | {:error, atom}
def channel_has_user?(client, channel, nick) do
GenServer.call(client, {:channel_has_user?, channel, nick})
end
@doc """
Add a new event handler process
"""
@spec add_handler(client :: pid, pid) :: :ok
def add_handler(client, pid) do
GenServer.call(client, {:add_handler, pid})
end
@doc """
Add a new event handler process, asynchronously
"""
@spec add_handler_async(client :: pid, pid) :: :ok
def add_handler_async(client, pid) do
GenServer.cast(client, {:add_handler, pid})
end
@doc """
Remove an event handler process
"""
@spec remove_handler(client :: pid, pid) :: :ok
def remove_handler(client, pid) do
GenServer.call(client, {:remove_handler, pid})
end
@doc """
Remove an event handler process, asynchronously
"""
@spec remove_handler_async(client :: pid, pid) :: :ok
def remove_handler_async(client, pid) do
GenServer.cast(client, {:remove_handler, pid})
end
@doc """
Get the current state of the provided client
"""
@spec state(client :: pid) :: [{atom, any}]
def state(client) do
state = GenServer.call(client, :state)
[server: state.server,
port: state.port,
nick: state.nick,
pass: state.pass,
user: state.user,
name: state.name,
autoping: state.autoping,
ssl?: state.ssl?,
connected?: state.connected?,
logged_on?: state.logged_on?,
channel_prefixes: state.channel_prefixes,
user_prefixes: state.user_prefixes,
channels: Channels.to_proplist(state.channels),
network: state.network,
login_time: state.login_time,
debug?: state.debug?,
event_handlers: state.event_handlers]
end
###############
# GenServer API
###############
@doc """
Called when GenServer initializes the client
"""
@spec init(list(any) | []) :: {:ok, ClientState.t}
def init(options \\ []) do
autoping = Keyword.get(options, :autoping, true)
debug = Keyword.get(options, :debug, false)
# Add event handlers
handlers =
Keyword.get(options, :event_handlers, [])
|> List.foldl([], &do_add_handler/2)
# Return initial state
{:ok, %ClientState{
event_handlers: handlers,
autoping: autoping,
logged_on?: false,
debug?: debug,
channels: ExIrc.Channels.init()}}
end
@doc """
Handle calls from the external API. It is not recommended to call these directly.
"""
# Handle call to get the current state of the client process
def handle_call(:state, _from, state), do: {:reply, state, state}
# Handle call to stop the current client process
def handle_call(:stop, _from, state) do
# Ensure the socket connection is closed if stop is called while still connected to the server
if state.connected?, do: Transport.close(state)
- {:stop, :normal, :ok, %{state | :connected? => false, :logged_on? => false, :socket => nil}}
+ {:stop, :normal, :ok, %{state | connected?: false, logged_on?: false, socket: nil}}
end
# Handles call to add a new event handler process
def handle_call({:add_handler, pid}, _from, state) do
handlers = do_add_handler(pid, state.event_handlers)
- {:reply, :ok, %{state | :event_handlers => handlers}}
+ {:reply, :ok, %{state | event_handlers: handlers}}
end
# Handles call to remove an event handler process
def handle_call({:remove_handler, pid}, _from, state) do
handlers = do_remove_handler(pid, state.event_handlers)
- {:reply, :ok, %{state | :event_handlers => handlers}}
+ {:reply, :ok, %{state | event_handlers: handlers}}
end
# Handle call to connect to an IRC server
def handle_call({:connect, server, port, options, ssl}, _from, state) do
# If there is an open connection already, close it.
if state.socket != nil, do: Transport.close(state)
# Set SSL mode
state = %{state | ssl?: ssl}
# Open a new connection
case Transport.connect(state, String.to_char_list(server), port, [:list, {:packet, :line}, {:keepalive, true}] ++ options) do
{:ok, socket} ->
send_event {:connected, server, port}, state
- {:reply, :ok, %{state | :connected? => true, :server => server, :port => port, :socket => socket}}
+ {:reply, :ok, %{state | connected?: true, server: server, port: port, socket: socket}}
error ->
{:reply, error, state}
end
end
# Handle call to determine if the client is connected
def handle_call(:is_connected?, _from, state), do: {:reply, state.connected?, state}
# Prevents any of the following messages from being handled if the client is not connected to a server.
# Instead, it returns {:error, :not_connected}.
- def handle_call(_, _from, %ClientState{:connected? => false} = state), do: {:reply, {:error, :not_connected}, state}
+ def handle_call(_, _from, %ClientState{connected?: false} = state), do: {:reply, {:error, :not_connected}, state}
# Handle call to login to the connected IRC server
- def handle_call({:logon, pass, nick, user, name}, _from, %ClientState{:logged_on? => false} = state) do
+ def handle_call({:logon, pass, nick, user, name}, _from, %ClientState{logged_on?: false} = state) do
Transport.send state, pass!(pass)
Transport.send state, nick!(nick)
Transport.send state, user!(user, name)
- {:reply, :ok, %{state | :pass => pass, :nick => nick, :user => user, :name => name} }
+ {:reply, :ok, %{state | pass: pass, nick: nick, user: user, name: name} }
end
# Handles call to change the client's nick.
- def handle_call({:nick, new_nick}, _from, %ClientState{:logged_on? => false} = state) do
+ def handle_call({:nick, new_nick}, _from, %ClientState{logged_on?: false} = state) do
Transport.send state, nick!(new_nick)
# Since we've not yet logged on, we won't get a nick change message, so we have to remember the nick here.
- {:reply, :ok, %{state | :nick => new_nick}}
+ {:reply, :ok, %{state | nick: new_nick}}
end
# Handle call to determine if client is logged on to a server
def handle_call(:is_logged_on?, _from, state), do: {:reply, state.logged_on?, state}
# Prevents any of the following messages from being handled if the client is not logged on to a server.
# Instead, it returns {:error, :not_logged_in}.
- def handle_call(_, _from, %ClientState{:logged_on? => false} = state), do: {:reply, {:error, :not_logged_in}, state}
+ def handle_call(_, _from, %ClientState{logged_on?: false} = state), do: {:reply, {:error, :not_logged_in}, state}
# Handles call to send a message
def handle_call({:msg, type, nick, msg}, _from, state) do
data = case type do
:privmsg -> privmsg!(nick, msg)
:notice -> notice!(nick, msg)
:ctcp -> notice!(nick, ctcp!(msg))
end
Transport.send state, data
{:reply, :ok, state}
end
# Handle /me messages
def handle_call({:me, channel, msg}, _from, state) do
data = me!(channel, msg)
Transport.send state, data
{:reply, :ok, state}
end
# Handles call to join a channel
def handle_call({:join, channel, key}, _from, state) do
Transport.send(state, join!(channel, key))
{:reply, :ok, state}
end
# Handles a call to leave a channel
def handle_call({:part, channel}, _from, state) do
Transport.send(state, part!(channel))
{:reply, :ok, state}
end
# Handles a call to kick a client
def handle_call({:kick, channel, nick, message}, _from, state) do
Transport.send(state, kick!(channel, nick, message))
{:reply, :ok, state}
end
# Handles a call to send the NAMES command to the server
def handle_call({:names, channel}, _from, state) do
Transport.send(state, names!(channel))
{:reply, :ok, state}
end
# Handles a call to change mode for a user or channel
def handle_call({:mode, channel_or_nick, flags, args}, _from, state) do
Transport.send(state, mode!(channel_or_nick, flags, args))
{:reply, :ok, state}
end
# Handle call to invite a user to a channel
def handle_call({:invite, nick, channel}, _from, state) do
Transport.send(state, invite!(nick, channel))
{:reply, :ok, state}
end
# Handle call to quit the server and close the socket connection
def handle_call({:quit, msg}, _from, state) do
if state.connected? do
Transport.send state, quit!(msg)
send_event :disconnected, state
Transport.close state
end
- {:reply, :ok, %{state | :connected? => false, :logged_on? => false, :socket => nil}}
+ {:reply, :ok, %{state | connected?: false, logged_on?: false, socket: nil}}
end
# Handles call to change the client's nick
def handle_call({:nick, new_nick}, _from, state) do Transport.send(state, nick!(new_nick)); {:reply, :ok, state} end
# Handles call to send a raw command to the IRC server
def handle_call({:cmd, raw_cmd}, _from, state) do Transport.send(state, command!(raw_cmd)); {:reply, :ok, state} end
# Handles call to return the client's channel data
def handle_call(:channels, _from, state), do: {:reply, Channels.channels(state.channels), state}
# Handles call to return a list of users for a given channel
def handle_call({:channel_users, channel}, _from, state), do: {:reply, Channels.channel_users(state.channels, channel), state}
# Handles call to return the given channel's topic
def handle_call({:channel_topic, channel}, _from, state), do: {:reply, Channels.channel_topic(state.channels, channel), state}
# Handles call to return the type of the given channel
def handle_call({:channel_type, channel}, _from, state), do: {:reply, Channels.channel_type(state.channels, channel), state}
# Handles call to determine if a nick is present in the given channel
def handle_call({:channel_has_user?, channel, nick}, _from, state) do
{:reply, Channels.channel_has_user?(state.channels, channel, nick), state}
end
# Handles message to add a new event handler process asynchronously
def handle_cast({:add_handler, pid}, state) do
handlers = do_add_handler(pid, state.event_handlers)
- {:noreply, %{state | :event_handlers => handlers}}
+ {:noreply, %{state | event_handlers: handlers}}
end
@doc """
Handles asynchronous messages from the external API. Not recommended to call these directly.
"""
# Handles message to remove an event handler process asynchronously
def handle_cast({:remove_handler, pid}, state) do
handlers = do_remove_handler(pid, state.event_handlers)
- {:noreply, %{state | :event_handlers => handlers}}
+ {:noreply, %{state | event_handlers: handlers}}
end
@doc """
Handle messages from the TCP socket connection.
"""
# Handles the client's socket connection 'closed' event
- def handle_info({:tcp_closed, _socket}, %ClientState{:server => server, :port => port} = state) do
+ def handle_info({:tcp_closed, _socket}, %ClientState{server: server, port: port} = state) do
info "Connection to #{server}:#{port} closed!"
send_event :disconnected, state
new_state = %{state |
- :socket => nil,
- :connected? => false,
- :logged_on? => false,
- :channels => Channels.init()
+ socket: nil,
+ connected?: false,
+ logged_on?: false,
+ channels: Channels.init()
}
{:noreply, new_state}
end
@doc """
Handle messages from the SSL socket connection.
"""
# Handles the client's socket connection 'closed' event
def handle_info({:ssl_closed, socket}, state) do
handle_info({:tcp_closed, socket}, state)
end
# Handles any TCP errors in the client's socket connection
- def handle_info({:tcp_error, socket, reason}, %ClientState{:server => server, :port => port} = state) do
+ def handle_info({:tcp_error, socket, reason}, %ClientState{server: server, port: port} = state) do
error "TCP error in connection to #{server}:#{port}:\r\n#{reason}\r\nClient connection closed."
new_state = %{state |
- :socket => nil,
- :connected? => false,
- :logged_on? => false,
- :channels => Channels.init()
+ socket: nil,
+ connected?: false,
+ logged_on?: false,
+ channels: Channels.init()
}
{:stop, {:tcp_error, socket}, new_state}
end
# Handles any SSL errors in the client's socket connection
def handle_info({:ssl_error, socket, reason}, state) do
handle_info({:tcp_error, socket, reason}, state)
end
# General handler for messages from the IRC server
def handle_info({:tcp, _, data}, state) do
debug? = state.debug?
case Utils.parse(data) do
- %IrcMessage{:ctcp => true} = msg ->
+ %IrcMessage{ctcp: true} = msg ->
handle_data msg, state
{:noreply, state}
- %IrcMessage{:ctcp => false} = msg ->
+ %IrcMessage{ctcp: false} = msg ->
handle_data msg, state
- %IrcMessage{:ctcp => :invalid} = msg when debug? ->
+ %IrcMessage{ctcp: :invalid} = msg when debug? ->
send_event msg, state
{:noreply, state}
_ ->
{:noreply, state}
end
end
# Wrapper for SSL socket messages
def handle_info({:ssl, socket, data}, state) do
handle_info({:tcp, socket, data}, state)
end
# If an event handler process dies, remove it from the list of event handlers
def handle_info({:DOWN, _, _, pid, _}, state) do
handlers = do_remove_handler(pid, state.event_handlers)
- {:noreply, %{state | :event_handlers => handlers}}
+ {:noreply, %{state | event_handlers: handlers}}
end
# Catch-all for unrecognized messages (do nothing)
def handle_info(_, state) do
{:noreply, state}
end
@doc """
Handle termination
"""
def terminate(_reason, state) do
if state.socket != nil do
Transport.close state
- %{state | :socket => nil}
+ %{state | socket: nil}
end
:ok
end
@doc """
Transform state for hot upgrades/downgrades
"""
def code_change(_old, state, _extra), do: {:ok, state}
################
# Data handling
################
@doc """
Handle IrcMessages received from the server.
"""
# Called upon successful login
- def handle_data(%IrcMessage{:cmd => @rpl_welcome}, %ClientState{:logged_on? => false} = state) do
+ def handle_data(%IrcMessage{cmd: @rpl_welcome}, %ClientState{logged_on?: false} = state) do
if state.debug?, do: debug "SUCCESFULLY LOGGED ON"
- new_state = %{state | :logged_on? => true, :login_time => :erlang.timestamp()}
+ new_state = %{state | logged_on?: true, login_time: :erlang.timestamp()}
send_event :logged_in, new_state
{:noreply, new_state}
end
# Called when the server sends it's current capabilities
- def handle_data(%IrcMessage{:cmd => @rpl_isupport} = msg, state) do
+ def handle_data(%IrcMessage{cmd: @rpl_isupport} = msg, state) do
if state.debug?, do: debug "RECEIVING SERVER CAPABILITIES"
{:noreply, Utils.isup(msg.args, state)}
end
# Called when the client enters a channel
- def handle_data(%IrcMessage{:nick => nick, :cmd => "JOIN"} = msg, %ClientState{:nick => nick} = state) do
+ def handle_data(%IrcMessage{nick: nick, cmd: "JOIN"} = msg, %ClientState{nick: nick} = state) do
channel = msg.args |> List.first |> String.strip
if state.debug?, do: debug "JOINED A CHANNEL #{channel}"
channels = Channels.join(state.channels, channel)
- new_state = %{state | :channels => channels}
+ new_state = %{state | channels: channels}
send_event {:joined, channel}, new_state
{:noreply, new_state}
end
# Called when another user joins a channel the client is in
- def handle_data(%IrcMessage{:nick => user_nick, :cmd => "JOIN"} = msg, state) do
+ def handle_data(%IrcMessage{nick: user_nick, cmd: "JOIN"} = msg, state) do
channel = msg.args |> List.first |> String.strip
if state.debug?, do: debug "ANOTHER USER JOINED A CHANNEL: #{channel} - #{user_nick}"
channels = Channels.user_join(state.channels, channel, user_nick)
- new_state = %{state | :channels => channels}
+ new_state = %{state | channels: channels}
send_event {:joined, channel, user_nick}, new_state
{:noreply, new_state}
end
# Called on joining a channel, to tell us the channel topic
# Message with three arguments is not RFC compliant but very common
# Message with two arguments is RFC compliant
- def handle_data(%IrcMessage{:cmd => @rpl_topic} = msg, state) do
+ def handle_data(%IrcMessage{cmd: @rpl_topic} = msg, state) do
{channel, topic} = case msg.args do
[_nick, channel, topic] -> {channel, topic}
[channel, topic] -> {channel, topic}
end
if state.debug? do
debug "INITIAL TOPIC MSG"
debug "1. TOPIC SET FOR #{channel} TO #{topic}"
end
channels = Channels.set_topic(state.channels, channel, topic)
- new_state = %{state | :channels => channels}
+ new_state = %{state | channels: channels}
send_event {:topic_changed, channel, topic}, new_state
{:noreply, new_state}
end
# Called when the topic changes while we're in the channel
- def handle_data(%IrcMessage{:cmd => "TOPIC", :args => [channel, topic]}, state) do
+ def handle_data(%IrcMessage{cmd: "TOPIC", args: [channel, topic]}, state) do
if state.debug?, do: debug "TOPIC CHANGED FOR #{channel} TO #{topic}"
channels = Channels.set_topic(state.channels, channel, topic)
- new_state = %{state | :channels => channels}
+ new_state = %{state | channels: channels}
send_event {:topic_changed, channel, topic}, new_state
{:noreply, new_state}
end
# Called when joining a channel with the list of current users in that channel, or when the NAMES command is sent
- def handle_data(%IrcMessage{:cmd => @rpl_namereply} = msg, state) do
+ def handle_data(%IrcMessage{cmd: @rpl_namereply} = msg, state) do
if state.debug?, do: debug "NAMES LIST RECEIVED"
{_nick, channel_type, channel, names} = case msg.args do
[nick, channel_type, channel, names] -> {nick, channel_type, channel, names}
[channel_type, channel, names] -> {nil, channel_type, channel, names}
end
channels = Channels.set_type(
Channels.users_join(state.channels, channel, String.split(names, " ", trim: true)),
channel,
channel_type)
send_event({:names_list, channel, names}, state)
- {:noreply, %{state | :channels => channels}}
+ {:noreply, %{state | channels: channels}}
end
# Called when our nick has succesfully changed
- def handle_data(%IrcMessage{:cmd => "NICK", :nick => nick, :args => [new_nick]}, %ClientState{:nick => nick} = state) do
+ def handle_data(%IrcMessage{cmd: "NICK", nick: nick, args: [new_nick]}, %ClientState{nick: nick} = state) do
if state.debug?, do: debug "NICK CHANGED FROM #{nick} TO #{new_nick}"
- new_state = %{state | :nick => new_nick}
+ new_state = %{state | nick: new_nick}
send_event {:nick_changed, new_nick}, new_state
{:noreply, new_state}
end
# Called when someone visible to us changes their nick
- def handle_data(%IrcMessage{:cmd => "NICK", :nick => nick, :args => [new_nick]}, state) do
+ def handle_data(%IrcMessage{cmd: "NICK", nick: nick, args: [new_nick]}, state) do
if state.debug?, do: debug "#{nick} CHANGED THEIR NICK TO #{new_nick}"
channels = Channels.user_rename(state.channels, nick, new_nick)
- new_state = %{state | :channels => channels}
+ new_state = %{state | channels: channels}
send_event {:nick_changed, nick, new_nick}, new_state
{:noreply, new_state}
end
# Called upon mode change
- def handle_data(%IrcMessage{:cmd => "MODE", args: [channel, op, user]}, state) do
+ def handle_data(%IrcMessage{cmd: "MODE", args: [channel, op, user]}, state) do
if state.debug?, do: debug "MODE #{channel} #{op} #{user}"
send_event {:mode, [channel, op, user]}, state
{:noreply, state}
end
# Called when we leave a channel
- def handle_data(%IrcMessage{:cmd => "PART", :nick => nick} = msg, %ClientState{:nick => nick} = state) do
+ def handle_data(%IrcMessage{cmd: "PART", nick: nick} = msg, %ClientState{nick: nick} = state) do
channel = msg.args |> List.first |> String.strip
if state.debug?, do: debug "WE LEFT A CHANNEL: #{channel}"
channels = Channels.part(state.channels, channel)
- new_state = %{state | :channels => channels}
+ new_state = %{state | channels: channels}
send_event {:parted, channel}, new_state
{:noreply, new_state}
end
# Called when someone else in our channel leaves
- def handle_data(%IrcMessage{:cmd => "PART", :nick => from, :host => host, :user => user} = msg, state) do
- sender = %SenderInfo{:nick => from, :host => host, :user => user}
+ def handle_data(%IrcMessage{cmd: "PART", nick: from, host: host, user: user} = msg, state) do
+ sender = %SenderInfo{nick: from, host: host, user: user}
channel = msg.args |> List.first |> String.strip
if state.debug?, do: debug "#{from} LEFT A CHANNEL: #{channel}"
channels = Channels.user_part(state.channels, channel, from)
- new_state = %{state | :channels => channels}
+ new_state = %{state | channels: channels}
send_event {:parted, channel, sender}, new_state
{:noreply, new_state}
end
# Called when we receive a PING
- def handle_data(%IrcMessage{:cmd => "PING"} = msg, %ClientState{:autoping => true} = state) do
+ def handle_data(%IrcMessage{cmd: "PING"} = msg, %ClientState{autoping: true} = state) do
if state.debug?, do: debug "RECEIVED A PING!"
case msg do
- %IrcMessage{:args => [from]} ->
+ %IrcMessage{args: [from]} ->
if state.debug?, do: debug("SENT PONG2")
Transport.send(state, pong2!(from, msg.server))
_ ->
if state.debug?, do: debug("SENT PONG1")
Transport.send(state, pong1!(state.nick))
end
{:noreply, state};
end
# Called when we are invited to a channel
- def handle_data(%IrcMessage{:cmd => "INVITE", :args => [nick, channel], :nick => by, :host => host, :user => user} = msg, %ClientState{:nick => nick} = state) do
- sender = %SenderInfo{:nick => by, :host => host, :user => user}
+ def handle_data(%IrcMessage{cmd: "INVITE", args: [nick, channel], nick: by, host: host, user: user} = msg, %ClientState{nick: nick} = state) do
+ sender = %SenderInfo{nick: by, host: host, user: user}
if state.debug?, do: debug "RECEIVED AN INVITE: #{msg.args |> Enum.join(" ")}"
send_event {:invited, sender, channel}, state
{:noreply, state}
end
# Called when we are kicked from a channel
- def handle_data(%IrcMessage{:cmd => "KICK", :args => [channel, nick], :nick => by, :host => host, :user => user} = _msg, %ClientState{:nick => nick} = state) do
- sender = %SenderInfo{:nick => by, :host => host, :user => user}
+ def handle_data(%IrcMessage{cmd: "KICK", args: [channel, nick], nick: by, host: host, user: user} = _msg, %ClientState{nick: nick} = state) do
+ sender = %SenderInfo{nick: by, host: host, user: user}
if state.debug?, do: debug "WE WERE KICKED FROM #{channel} BY #{by}"
send_event {:kicked, sender, channel}, state
{:noreply, state}
end
# Called when someone else was kicked from a channel
- def handle_data(%IrcMessage{:cmd => "KICK", :args => [channel, nick], :nick => by, :host => host, :user => user} = _msg, state) do
- sender = %SenderInfo{:nick => by, :host => host, :user => user}
+ def handle_data(%IrcMessage{cmd: "KICK", args: [channel, nick], nick: by, host: host, user: user} = _msg, state) do
+ sender = %SenderInfo{nick: by, host: host, user: user}
if state.debug?, do: debug "#{nick} WAS KICKED FROM #{channel} BY #{by}"
send_event {:kicked, nick, sender, channel}, state
{:noreply, state}
end
# Called when someone sends us a message
- def handle_data(%IrcMessage{:nick => from, :cmd => "PRIVMSG", :args => [nick, message], :host => host, :user => user} = _msg, %ClientState{:nick => nick} = state) do
- sender = %SenderInfo{:nick => from, :host => host, :user => user}
+ def handle_data(%IrcMessage{nick: from, cmd: "PRIVMSG", args: [nick, message], host: host, user: user} = _msg, %ClientState{nick: nick} = state) do
+ sender = %SenderInfo{nick: from, host: host, user: user}
if state.debug?, do: debug "#{from} SENT US #{message}"
send_event {:received, message, sender}, state
{:noreply, state}
end
# Called when someone sends a message to a channel we're in, or a list of users
- def handle_data(%IrcMessage{:nick => from, :cmd => "PRIVMSG", :args => [to, message], :host => host, :user => user} = _msg, %ClientState{:nick => nick} = state) do
- sender = %SenderInfo{:nick => from, :host => host, :user => user}
+ def handle_data(%IrcMessage{nick: from, cmd: "PRIVMSG", args: [to, message], host: host, user: user} = _msg, %ClientState{nick: nick} = state) do
+ sender = %SenderInfo{nick: from, host: host, user: user}
if state.debug?, do: debug "#{from} SENT #{message} TO #{to}"
send_event {:received, message, sender, to}, state
# If we were mentioned, fire that event as well
if String.contains?(message, nick), do: send_event({:mentioned, message, sender, to}, state)
{:noreply, state}
end
# Called when someone uses ACTION, i.e. `/me dies`
- def handle_data(%IrcMessage{:nick => from, :cmd => "ACTION", :args => [channel, message], :host => host, :user => user} = _msg, state) do
- sender = %SenderInfo{:nick => from, :host => host, :user => user}
+ def handle_data(%IrcMessage{nick: from, cmd: "ACTION", args: [channel, message], host: host, user: user} = _msg, state) do
+ sender = %SenderInfo{nick: from, host: host, user: user}
if state.debug?, do: debug "* #{from} #{message} in #{channel}"
send_event {:me, message, sender, channel}, state
{:noreply, state}
end
# Called any time we receive an unrecognized message
def handle_data(msg, state) do
if state.debug? do debug "UNRECOGNIZED MSG: #{msg.cmd}"; IO.inspect(msg) end
send_event {:unrecognized, msg.cmd, msg}, state
{:noreply, state}
end
###############
# Internal API
###############
- defp send_event(msg, %ClientState{:event_handlers => handlers}) when is_list(handlers) do
+ defp send_event(msg, %ClientState{event_handlers: handlers}) when is_list(handlers) do
Enum.each(handlers, fn({pid, _}) -> Kernel.send(pid, msg) end)
end
defp do_add_handler(pid, handlers) do
case Enum.member?(handlers, pid) do
false ->
ref = Process.monitor(pid)
[{pid, ref} | handlers]
true ->
handlers
end
end
defp do_remove_handler(pid, handlers) do
case List.keyfind(handlers, pid, 0) do
{pid, ref} ->
Process.demonitor(ref)
List.keydelete(handlers, pid, 0)
nil ->
handlers
end
end
defp debug(msg) do
IO.puts(IO.ANSI.green() <> msg <> IO.ANSI.reset())
end
end
diff --git a/lib/exirc/example_handler.ex b/lib/exirc/example_handler.ex
index 251afaf..48774fd 100644
--- a/lib/exirc/example_handler.ex
+++ b/lib/exirc/example_handler.ex
@@ -1,132 +1,132 @@
defmodule ExampleHandler do
@moduledoc """
This is an example event handler that you can attach to the client using
`add_handler` or `add_handler_async`. To remove, call `remove_handler` or
`remove_handler_async` with the pid of the handler process.
"""
def start! do
start_link([])
end
def start_link(_) do
GenServer.start_link(__MODULE__, nil, [])
end
def init(_) do
{:ok, nil}
end
@doc """
Handle messages from the client
Examples:
def handle_info({:connected, server, port}, _state) do
IO.puts "Connected to \#{server}:\#{port}"
end
def handle_info(:logged_in, _state) do
IO.puts "Logged in!"
end
- def handle_info(%IrcMessage{:nick => from, :cmd => "PRIVMSG", :args => ["mynick", msg]}, _state) do
+ def handle_info(%IrcMessage{nick: from, cmd: "PRIVMSG", args: ["mynick", msg]}, _state) do
IO.puts "Received a private message from \#{from}: \#{msg}"
end
- def handle_info(%IrcMessage{:nick => from, :cmd => "PRIVMSG", :args => [to, msg]}, _state) do
+ def handle_info(%IrcMessage{nick: from, cmd: "PRIVMSG", args: [to, msg]}, _state) do
IO.puts "Received a message in \#{to} from \#{from}: \#{msg}"
end
"""
def handle_info({:connected, server, port}, _state) do
debug "Connected to #{server}:#{port}"
{:noreply, nil}
end
def handle_info(:logged_in, _state) do
debug "Logged in to server"
{:noreply, nil}
end
def handle_info(:disconnected, _state) do
debug "Disconnected from server"
{:noreply, nil}
end
def handle_info({:joined, channel}, _state) do
debug "Joined #{channel}"
{:noreply, nil}
end
def handle_info({:joined, channel, user}, _state) do
debug "#{user} joined #{channel}"
{:noreply, nil}
end
def handle_info({:topic_changed, channel, topic}, _state) do
debug "#{channel} topic changed to #{topic}"
{:noreply, nil}
end
def handle_info({:nick_changed, nick}, _state) do
debug "We changed our nick to #{nick}"
{:noreply, nil}
end
def handle_info({:nick_changed, old_nick, new_nick}, _state) do
debug "#{old_nick} changed their nick to #{new_nick}"
{:noreply, nil}
end
def handle_info({:parted, channel}, _state) do
debug "We left #{channel}"
{:noreply, nil}
end
def handle_info({:parted, channel, sender}, _state) do
nick = sender.nick
debug "#{nick} left #{channel}"
{:noreply, nil}
end
def handle_info({:invited, sender, channel}, _state) do
by = sender.nick
debug "#{by} invited us to #{channel}"
{:noreply, nil}
end
def handle_info({:kicked, sender, channel}, _state) do
by = sender.nick
debug "We were kicked from #{channel} by #{by}"
{:noreply, nil}
end
def handle_info({:kicked, nick, sender, channel}, _state) do
by = sender.nick
debug "#{nick} was kicked from #{channel} by #{by}"
{:noreply, nil}
end
def handle_info({:received, message, sender}, _state) do
from = sender.nick
debug "#{from} sent us a private message: #{message}"
{:noreply, nil}
end
def handle_info({:received, message, sender, channel}, _state) do
from = sender.nick
debug "#{from} sent a message to #{channel}: #{message}"
{:noreply, nil}
end
def handle_info({:mentioned, message, sender, channel}, _state) do
from = sender.nick
debug "#{from} mentioned us in #{channel}: #{message}"
{:noreply, nil}
end
def handle_info({:me, message, sender, channel}, _state) do
from = sender.nick
debug "* #{from} #{message} in #{channel}"
{:noreply, nil}
end
# This is an example of how you can manually catch commands if ExIrc.Client doesn't send a specific message for it
- def handle_info(%IrcMessage{:nick => from, :cmd => "PRIVMSG", :args => ["testnick", msg]}, _state) do
+ def handle_info(%IrcMessage{nick: from, cmd: "PRIVMSG", args: ["testnick", msg]}, _state) do
debug "Received a private message from #{from}: #{msg}"
{:noreply, nil}
end
- def handle_info(%IrcMessage{:nick => from, :cmd => "PRIVMSG", :args => [to, msg]}, _state) do
+ def handle_info(%IrcMessage{nick: from, cmd: "PRIVMSG", args: [to, msg]}, _state) do
debug "Received a message in #{to} from #{from}: #{msg}"
{:noreply, nil}
end
# Catch-all for messages you don't care about
def handle_info(msg, _state) do
debug "Received IrcMessage:"
IO.inspect msg
{:noreply, nil}
end
defp debug(msg) do
IO.puts IO.ANSI.yellow() <> msg <> IO.ANSI.reset()
end
end
diff --git a/lib/exirc/utils.ex b/lib/exirc/utils.ex
index 076a497..2293972 100644
--- a/lib/exirc/utils.ex
+++ b/lib/exirc/utils.ex
@@ -1,187 +1,187 @@
defmodule ExIrc.Utils do
######################
# IRC Message Parsing
######################
@doc """
Parse an IRC message
Example:
data = ':irc.example.org 005 nick NETWORK=Freenode PREFIX=(ov)@+ CHANTYPES=#&'
message = ExIrc.Utils.parse data
assert "irc.example.org" = message.server
"""
@spec parse(raw_data :: char_list) :: IrcMessage.t
def parse(raw_data) do
data = :string.substr(raw_data, 1, length(raw_data))
case data do
[?:|_] ->
[[?:|from]|rest] = :string.tokens(data, ' ')
get_cmd(rest, parse_from(from, %IrcMessage{ctcp: false}))
data ->
get_cmd(:string.tokens(data, ' '), %IrcMessage{ctcp: false})
end
end
@split_pattern ~r/(!|@|\.)/
defp parse_from(from, msg) do
from_str = IO.iodata_to_binary(from)
splits = Regex.scan(@split_pattern, from_str, return: :index)
|> Enum.map(fn [{start, len},_] -> binary_part(from_str, start, len) end)
parts = Regex.split(@split_pattern, from_str)
woven = weave(splits, parts)
case woven do
[nick, "!", user, "@" | host] ->
- %{msg | :nick => nick, :user => user, :host => Enum.join(host)}
+ %{msg | nick: nick, user: user, host: Enum.join(host)}
[nick, "@" | host] ->
- %{msg | :nick => nick, :host => Enum.join(host)}
+ %{msg | nick: nick, host: Enum.join(host)}
[_, "." | _] ->
# from is probably a server name
- %{msg | :server => to_string(from)}
+ %{msg | server: to_string(from)}
[nick] ->
- %{msg | :nick => nick}
+ %{msg | nick: nick}
end
end
# Parse command from message
defp get_cmd([cmd, arg1, [?:, 1 | ctcp_trail] | restargs], msg) when cmd == 'PRIVMSG' or cmd == 'NOTICE' do
get_cmd([cmd, arg1, [1 | ctcp_trail] | restargs], msg)
end
defp get_cmd([cmd, target, [1 | ctcp_cmd] | cmd_args], msg) when cmd == 'PRIVMSG' or cmd == 'NOTICE' do
args = cmd_args
|> Enum.map(&Enum.take_while(&1, fn c -> c != 0o001 end))
|> Enum.map(&List.to_string/1)
case args do
args when args != [] ->
%{msg |
- :cmd => to_string(ctcp_cmd),
- :args => [to_string(target), args |> Enum.join(" ")],
- :ctcp => true
+ cmd: to_string(ctcp_cmd),
+ args: [to_string(target), args |> Enum.join(" ")],
+ ctcp: true
}
_ ->
- %{msg | :cmd => to_string(cmd), :ctcp => :invalid}
+ %{msg | cmd: to_string(cmd), ctcp: :invalid}
end
end
defp get_cmd([cmd | rest], msg) do
- get_args(rest, %{msg | :cmd => to_string(cmd)})
+ get_args(rest, %{msg | cmd: to_string(cmd)})
end
# Parse command args from message
defp get_args([], msg) do
args = msg.args
|> Enum.reverse
|> Enum.filter(fn(arg) -> arg != [] end)
|> Enum.map(&trim_crlf/1)
|> Enum.map(&List.to_string/1)
- %{msg | :args => args}
+ %{msg | args: args}
end
defp get_args([[?: | first_arg] | rest], msg) do
args = (for arg <- [first_arg | rest], do: ' ' ++ trim_crlf(arg)) |> List.flatten
case args do
[_ | []] ->
- get_args [], %{msg | :args => [msg.args]}
+ get_args [], %{msg | args: [msg.args]}
[_ | full_trail] ->
- get_args [], %{msg | :args => [full_trail | msg.args]}
+ get_args [], %{msg | args: [full_trail | msg.args]}
end
end
defp get_args([arg | []], msg) do
- get_args [], %{msg | :args => [arg | msg.args]}
+ get_args [], %{msg | args: [arg | msg.args]}
end
defp get_args([arg | rest], msg) do
- get_args rest, %{msg | :args => [arg | msg.args]}
+ get_args rest, %{msg | args: [arg | msg.args]}
end
############################
# Parse RPL_ISUPPORT (005)
############################
@doc """
Parse RPL_ISUPPORT message.
If an empty list is provided, do nothing, otherwise parse CHANTYPES,
NETWORK, and PREFIX parameters for relevant data.
"""
@spec isup(parameters :: list(binary), state :: ExIrc.Client.ClientState.t) :: ExIrc.Client.ClientState.t
def isup([], state), do: state
def isup([param | rest], state) do
try do
isup(rest, isup_param(param, state))
rescue
_ -> isup(rest, state)
end
end
defp isup_param("CHANTYPES=" <> channel_prefixes, state) do
prefixes = channel_prefixes |> String.split("", trim: true)
- %{state | :channel_prefixes => prefixes}
+ %{state | channel_prefixes: prefixes}
end
defp isup_param("NETWORK=" <> network, state) do
- %{state | :network => network}
+ %{state | network: network}
end
defp isup_param("PREFIX=" <> user_prefixes, state) do
prefixes = Regex.run(~r/\((.*)\)(.*)/, user_prefixes, capture: :all_but_first)
|> Enum.map(&String.to_char_list/1)
|> List.zip
- %{state | :user_prefixes => prefixes}
+ %{state | user_prefixes: prefixes}
end
defp isup_param(_, state) do
state
end
###################
# Helper Functions
###################
@days_of_week ['Mon','Tue','Wed','Thu','Fri','Sat','Sun']
@months_of_year ['Jan','Feb','Mar','Apr','May','Jun','Jul','Aug','Sep','Oct','Nov','Dec']
@doc """
Get CTCP formatted time from a tuple representing the current calendar time:
Example:
iex> local_time = {{2013,12,6},{14,5,0}}
{{2013,12,6},{14,5,0}}
iex> ExIrc.Utils.ctcp_time local_time
"Fri Dec 06 14:05:00 2013"
"""
@spec ctcp_time(datetime :: {{integer, integer, integer}, {integer, integer, integer}}) :: binary
def ctcp_time({{y, m, d}, {h, n, s}} = _datetime) do
[:lists.nth(:calendar.day_of_the_week(y,m,d), @days_of_week),
' ',
:lists.nth(m, @months_of_year),
' ',
:io_lib.format("~2..0s", [Integer.to_char_list(d)]),
' ',
:io_lib.format("~2..0s", [Integer.to_char_list(h)]),
':',
:io_lib.format("~2..0s", [Integer.to_char_list(n)]),
':',
:io_lib.format("~2..0s", [Integer.to_char_list(s)]),
' ',
Integer.to_char_list(y)] |> List.flatten |> List.to_string
end
defp trim_crlf(charlist) do
case Enum.reverse(charlist) do
[?\n, ?\r | text] -> Enum.reverse(text)
_ -> charlist
end
end
defp weave(xs, ys) do
do_weave(xs, ys, [])
|> Enum.filter(fn "" -> false; _ -> true end)
end
defp do_weave([], ys, result), do: (ys ++ result) |> Enum.reverse
defp do_weave(xs, [], result), do: (xs ++ result) |> Enum.reverse
defp do_weave([hx|xs], [hy|ys], result), do: do_weave(xs, ys, [hx, hy | result])
end