yaic 0.1.0 → 0.2.0

data/lib/yaic/event.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Yaic
+  class Event
+    attr_reader :type, :message
+
+    def initialize(type:, message: nil, **attributes)
+      @type = type
+      @message = message
+      @attributes = attributes
+    end
+
+    def [](key)
+      @attributes[key]
+    end
+
+    def to_h
+      @attributes.dup
+    end
+
+    private
+
+    def respond_to_missing?(method_name, include_private = false)
+      @attributes.key?(method_name) || super
+    end
+
+    def method_missing(method_name, *args)
+      if @attributes.key?(method_name) && args.empty?
+        @attributes[method_name]
+      else
+        super
+      end
+    end
+  end
+end

data/lib/yaic/message.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+require "strscan"
+
+module Yaic
+  class Message
+    attr_reader :tags, :source, :command, :params, :raw
+
+    def initialize(tags: {}, source: nil, command: nil, params: [])
+      @tags = tags
+      @source = source
+      @command = command
+      @params = params
+      @raw = nil
+    end
+
+    def self.parse(str)
+      return nil if str.nil? || str.empty?
+
+      str = str.b.force_encoding("UTF-8")
+      str = str.encode("UTF-8", "ISO-8859-1", invalid: :replace, undef: :replace) unless str.valid_encoding?
+
+      stripped = str.chomp("\r\n").chomp("\n")
+      return nil if stripped.empty?
+
+      scanner = StringScanner.new(stripped)
+
+      tags = parse_tags(scanner)
+      source = parse_source(scanner)
+      command = parse_command(scanner)
+      params = parse_params(scanner)
+
+      msg = new(tags: tags, source: source, command: command, params: params)
+      msg.instance_variable_set(:@raw, str)
+      msg
+    end
+
+    def to_s
+      parts = []
+      parts << @command
+
+      @params.each_with_index do |param, idx|
+        is_last = idx == @params.length - 1
+        parts << if is_last && needs_trailing_prefix?(param, @params.length)
+          ":#{param}"
+        else
+          param
+        end
+      end
+
+      "#{parts.join(" ")}\r\n"
+    end
+
+    private
+
+    def needs_trailing_prefix?(param, param_count)
+      param.empty? || param.include?(" ") || param.start_with?(":") || param_count > 1
+    end
+
+    class << self
+      private
+
+      def parse_tags(scanner)
+        tags = {}
+
+        if scanner.peek(1) == "@"
+          scanner.getch
+          tag_str = scanner.scan(/[^ ]+/)
+          skip_spaces(scanner)
+
+          tag_str&.split(";")&.each do |tag|
+            key, value = tag.split("=", 2)
+            tags[key] = value || ""
+          end
+        end
+
+        tags
+      end
+
+      def parse_source(scanner)
+        return nil unless scanner.peek(1) == ":"
+
+        scanner.getch
+        source_str = scanner.scan(/[^ ]+/)
+        skip_spaces(scanner)
+
+        Source.parse(source_str)
+      end
+
+      def parse_command(scanner)
+        cmd = scanner.scan(/[A-Za-z]+|\d{3}/)
+        skip_spaces(scanner)
+        cmd
+      end
+
+      def parse_params(scanner)
+        params = []
+
+        until scanner.eos?
+          if scanner.peek(1) == ":"
+            scanner.getch
+            params << scanner.rest
+            break
+          else
+            param = scanner.scan(/[^ ]+/)
+            params << param if param
+            skip_spaces(scanner)
+          end
+        end
+
+        params
+      end
+
+      def skip_spaces(scanner)
+        scanner.skip(/ +/)
+      end
+    end
+  end
+end

data/lib/yaic/registration.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Yaic
+  module Registration
+    def self.pass_message(password)
+      Message.new(command: "PASS", params: [password])
+    end
+
+    def self.nick_message(nickname)
+      Message.new(command: "NICK", params: [nickname])
+    end
+
+    def self.user_message(username, realname)
+      Message.new(command: "USER", params: [username, "0", "*", realname])
+    end
+  end
+end

data/lib/yaic/socket.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+require "socket"
+require "openssl"
+
+module Yaic
+  class Socket
+    def state
+      @monitor.synchronize { @state }
+    end
+
+    def initialize(host, port, ssl: false, verify_mode: nil, connect_timeout: 30)
+      @host = host
+      @port = port
+      @ssl = ssl
+      @verify_mode = verify_mode || OpenSSL::SSL::VERIFY_NONE
+      @connect_timeout = connect_timeout
+
+      @socket = nil
+      @read_buffer = String.new(encoding: Encoding::ASCII_8BIT)
+      @write_queue = []
+      @state = :disconnected
+      @monitor = Monitor.new
+    end
+
+    def connect
+      tcp_socket = TCPSocket.new(@host, @port, connect_timeout: @connect_timeout)
+      tcp_socket.setsockopt(::Socket::SOL_SOCKET, ::Socket::SO_KEEPALIVE, true)
+
+      @monitor.synchronize do
+        @socket = @ssl ? wrap_ssl(tcp_socket) : tcp_socket
+        @state = :connecting
+      end
+    rescue Errno::ETIMEDOUT, Errno::EHOSTUNREACH, Errno::ECONNREFUSED, IO::TimeoutError, SocketError => e
+      raise Yaic::ConnectionError, e.message
+    end
+
+    def disconnect
+      @monitor.synchronize do
+        return if @state == :disconnected
+
+        begin
+          @socket&.close
+        rescue
+          nil
+        end
+        @socket = nil
+        @read_buffer.clear
+        @write_queue.clear
+        @state = :disconnected
+      end
+    end
+
+    def read
+      @monitor.synchronize do
+        return nil if @socket.nil?
+
+        begin
+          data = @socket.read_nonblock(4096)
+          buffer_data(data)
+          extract_message
+        rescue IO::WaitReadable
+          extract_message
+        rescue IOError, Errno::ECONNRESET
+          nil
+        end
+      end
+    end
+
+    def write(message)
+      @monitor.synchronize do
+        return if @socket.nil?
+
+        message = message.dup
+        message << "\r\n" unless message.end_with?("\r\n", "\n")
+
+        begin
+          @socket.write_nonblock(message)
+        rescue IO::WaitWritable
+          @write_queue << message
+          flush_write_queue
+        end
+      end
+    end
+
+    private
+
+    def wrap_ssl(tcp_socket)
+      context = OpenSSL::SSL::SSLContext.new
+      context.verify_mode = @verify_mode
+
+      ssl_socket = OpenSSL::SSL::SSLSocket.new(tcp_socket, context)
+      ssl_socket.hostname = @host
+      ssl_socket.sync = true
+      ssl_socket.connect
+      ssl_socket
+    end
+
+    def buffer_data(data)
+      @read_buffer << data
+    end
+
+    def extract_message
+      if (idx = @read_buffer.index("\n"))
+        @read_buffer.slice!(0..idx)
+      end
+    end
+
+    def flush_write_queue
+      while @write_queue.any?
+        begin
+          @socket.write_nonblock(@write_queue.first)
+          @write_queue.shift
+        rescue IO::WaitWritable
+          break
+        end
+      end
+    end
+  end
+end

data/lib/yaic/source.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Yaic
+  class Source
+    attr_reader :nick, :user, :host, :raw
+
+    def initialize(nick: nil, user: nil, host: nil, raw: nil)
+      @nick = nick
+      @user = user
+      @host = host
+      @raw = raw
+    end
+
+    def self.parse(str)
+      return nil if str.nil? || str.empty?
+
+      nick = nil
+      user = nil
+      host = nil
+
+      if str.include?("!")
+        nick, rest = str.split("!", 2)
+        if rest.include?("@")
+          user, host = rest.split("@", 2)
+        else
+          user = rest
+        end
+      elsif str.include?("@")
+        nick, host = str.split("@", 2)
+      elsif str.include?(".")
+        host = str
+      else
+        nick = str
+      end
+
+      new(nick: nick, user: user, host: host, raw: str)
+    end
+  end
+end

data/lib/yaic/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Yaic
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/lib/yaic/who_result.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Yaic
+  class WhoResult
+    attr_reader :channel, :user, :host, :server, :nick, :away, :realname
+
+    def initialize(channel:, user:, host:, server:, nick:, away:, realname:)
+      @channel = channel
+      @user = user
+      @host = host
+      @server = server
+      @nick = nick
+      @away = away
+      @realname = realname
+    end
+  end
+end

data/lib/yaic/whois_result.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Yaic
+  class WhoisResult
+    attr_accessor :nick, :user, :host, :realname, :channels, :server, :idle, :signon, :account, :away
+
+    def initialize(nick:)
+      @nick = nick
+      @user = nil
+      @host = nil
+      @realname = nil
+      @channels = []
+      @server = nil
+      @idle = nil
+      @signon = nil
+      @account = nil
+      @away = nil
+    end
+  end
+end

data/lib/yaic.rb

@@ -1,8 +1,20 @@
 # frozen_string_literal: true
 
+require "monitor"
+
 require_relative "yaic/version"
+require_relative "yaic/source"
+require_relative "yaic/message"
+require_relative "yaic/socket"
+require_relative "yaic/registration"
+require_relative "yaic/event"
+require_relative "yaic/channel"
+require_relative "yaic/who_result"
+require_relative "yaic/whois_result"
+require_relative "yaic/client"
 
 module Yaic
   class Error < StandardError; end
-  # Your code goes here...
+  class TimeoutError < Error; end
+  class ConnectionError < Error; end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: yaic
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Joé Dupuis
@@ -15,17 +15,67 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".claude/agents/ralph-qa.md"
+- ".claude/ralph/bin/dump-pid.sh"
+- ".claude/ralph/bin/kill-claude"
+- ".claude/ralph/bin/start-ralph"
+- ".claude/ralph/bin/stop-hook.sh"
+- ".claude/ralph/bin/stop-ralph"
+- ".claude/ralph/prompt.md"
+- ".claude/settings.json"
 - ".dockerignore"
+- ".gitmodules"
 - ".ruby-version"
 - CHANGELOG.md
+- CLAUDE.md
 - LICENSE.txt
 - README.md
 - Rakefile
 - devenv.lock
 - devenv.nix
 - devenv.yaml
+- docs/agents/data-model.md
+- docs/agents/ralph/features/01-message-parsing.md.done
+- docs/agents/ralph/features/01-tcpsocket-refactor.md.done
+- docs/agents/ralph/features/02-connection-socket.md.done
+- docs/agents/ralph/features/02-simplified-client-api.md.done
+- docs/agents/ralph/features/03-registration.md.done
+- docs/agents/ralph/features/04-ping-pong.md.done
+- docs/agents/ralph/features/05-event-system.md.done
+- docs/agents/ralph/features/06-privmsg-notice.md.done
+- docs/agents/ralph/features/07-join-part.md.done
+- docs/agents/ralph/features/08-quit.md.done
+- docs/agents/ralph/features/09-nick-change.md.done
+- docs/agents/ralph/features/10-topic.md.done
+- docs/agents/ralph/features/11-kick.md.done
+- docs/agents/ralph/features/12-names.md.done
+- docs/agents/ralph/features/13-mode.md.done
+- docs/agents/ralph/features/14-who-whois.md.done
+- docs/agents/ralph/features/15-client-api.md.done
+- docs/agents/ralph/features/16-ssl-test-infrastructure.md.done
+- docs/agents/ralph/features/17-github-actions-ci.md.done
+- docs/agents/ralph/features/18-brakeman-security-scanning.md.done
+- docs/agents/ralph/features/19-fix-qa.md.done
+- docs/agents/ralph/features/20-test-optimization.md.done
+- docs/agents/ralph/features/21-test-parallelization.md.done
+- docs/agents/ralph/features/22-wait-until-pattern.md.done
+- docs/agents/ralph/features/23-ping-test-optimization.md.done
+- docs/agents/ralph/features/24-blocking-who-whois.md.done
+- docs/agents/ralph/features/25-verbose-mode.md.done
+- docs/agents/ralph/plans/test-optimization-plan.md
+- docs/agents/ralph/progress.md
+- docs/agents/todo.md
 - lib/yaic.rb
+- lib/yaic/channel.rb
+- lib/yaic/client.rb
+- lib/yaic/event.rb
+- lib/yaic/message.rb
+- lib/yaic/registration.rb
+- lib/yaic/socket.rb
+- lib/yaic/source.rb
 - lib/yaic/version.rb
+- lib/yaic/who_result.rb
+- lib/yaic/whois_result.rb
 - sig/yaic.rbs
 homepage: https://github.com/JoeDupuis/yaic
 licenses: