iris_ruby 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 4a9b7e41ecec4762e6334f03e230bef908e5777d49932ff92e4c5c539812e04a
+  data.tar.gz: 735d93cef5dfcf5ba163b5abfc6e904e569e29b20efd867904692078c87d7762
+SHA512:
+  metadata.gz: 1a4751059a6817e5a6d3528f1f087ca5c1719c61bb4ba3fd63b05d4eeab90ffb2a7c6e6f91f239e2ab857eff99c41b7cef7d7ea9a2fc6f2a6bee254342dbe273
+  data.tar.gz: 26f5522b43b69d3f9d7879f308ec5b035dce88f0dcff1c02ffa73783fe7bb37bbd2b39db2e59a4f700413e019a9b2a4419548aaa1d71770cb5acfe5e21da0903

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 qweruby
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,246 @@
+# IrisRb
+
+Iris(https://github.com/dolidolih/Iris) 를 기반으로 루비로 포팅한 레포
+
+## 설치
+
+###
+- Ruby ~>3.4.0 
+
+### How use
+
+```bash
+gem install bundler
+bundle install
+```
+
+## 빠른 시작
+
+### 기본 사용법
+
+```ruby
+require_relative 'lib/iris_rb/client'
+
+def on_message(chat)
+  if msg == ".hi"
+    reply("Hello #{chat[:sender][:name]}")
+  elsif msg == ".이미지"
+    send_image(chat[:room][:id], "./image/example.jpg")
+  end
+end
+
+def on_newmem(chat)
+  reply("#{chat[:sender][:name]}님 환영합니다!")
+end
+
+def on_delmem(chat)
+  reply("#{chat[:sender][:name]}님 안녕히 가세요!")
+end
+
+client = IrisRb::Client.new(
+  url: "http://localhost:3000",
+  hot_reload: true
+)
+
+sleep
+```
+
+## API 문서
+
+### Client 초기화
+
+```ruby
+client = IrisRb::Client.new(
+  url: "http://localhost:3000",  # Iris 서버 URL
+  hot_reload: true                # 개발 모드 (파일 변경 시 자동 재시작)
+)
+```
+
+#### 파라미터
+
+- `url` (필수): Iris 서버의 HTTP URL
+- `hot_reload` (선택): 파일 변경 감지 및 자동 재시작 활성화 (기본값: false)
+
+### 이벤트 핸들러
+
+#### on_message(chat)
+
+일반 메시지를 받았을 때 호출됩니다.
+
+```ruby
+def on_message(chat)
+  # chat 객체 구조:
+  # {
+  #   room: { id: "...", name: "...", type: "..." },
+  #   sender: { id: "...", name: "..." },
+  #   message: { id: "...", type: "...", content: "...", attachment: {}, v: {} }
+  # }
+end
+```
+
+#### on_newmem(chat)
+
+새로운 멤버가 입장했을 때 호출됩니다.
+
+```ruby
+def on_newmem(chat)
+  reply("환영합니다!")
+end
+```
+
+#### on_delmem(chat)
+
+멤버가 퇴장했을 때 호출됩니다.
+
+```ruby
+def on_delmem(chat)
+  reply("안녕히 가세요!")
+end
+```
+
+### 메시지 전송
+
+#### reply(message)
+
+현재 방에 텍스트 메시지를 전송합니다.
+
+```ruby
+reply("안녕하세요!")
+```
+
+#### send_image(room_id, image_path_or_base64)
+
+이미지를 전송합니다.
+
+```ruby
+# 파일 경로로 전송
+send_image(chat[:room][:id], "./image/photo.jpg")
+
+# Base64 문자열로 전송
+send_image(chat[:room][:id], "iVBORw0KGgoAAAANSUhEUgAA...")
+```
+
+#### send_image_multiple(room_id, image_base64s)
+
+여러 이미지를 한 번에 전송합니다.
+
+```ruby
+client.send_image_multiple(room_id, [base64_image1, base64_image2])
+```
+
+### 데이터베이스 쿼리
+
+#### query(query_str, bind = [])
+
+SQL 쿼리를 실행합니다.
+
+```ruby
+# 단순 쿼리
+result = client.query("SELECT * FROM users")
+
+# Prepared statement
+result = client.query("SELECT * FROM users WHERE id = ?", [user_id])
+```
+
+### 헬퍼 함수
+
+#### msg
+
+현재 메시지의 내용을 반환합니다 (전역 변수).
+
+```ruby
+def on_message(chat)
+  if msg == ".help"
+    reply("도움말...")
+  end
+end
+```
+
+## Chat 객체 구조
+
+```ruby
+{
+  room: {
+    id: "방 ID",
+    name: "방 이름",
+    type: "방 타입"
+  },
+  sender: {
+    id: "발신자 ID",
+    name: "발신자 닉네임"
+  },
+  message: {
+    id: "메시지 ID",
+    type: "메시지 타입",
+    content: "메시지 내용",
+    attachment: {},  # 첨부파일 정보
+    v: {}           # 추가 메타데이터
+  },
+  raw: "원본 JSON 문자열"
+}
+```
+
+## 예제
+
+### 에코 봇
+
+```ruby
+def on_message(chat)
+  reply("Echo: #{msg}")
+end
+```
+
+### 명령어 봇
+
+```ruby
+def on_message(chat)
+  case msg
+  when ".안녕"
+    reply("안녕하세요!")
+  when ".시간"
+    reply(Time.now.strftime("%Y-%m-%d %H:%M:%S"))
+  when /^.계산 (.+)/
+    expression = $1
+    begin
+      result = eval(expression)
+      reply("결과: #{result}")
+    rescue
+      reply("계산 오류")
+    end
+  end
+end
+```
+
+### 이미지 전송 봇
+
+```ruby
+def on_message(chat)
+  if msg == ".고양이"
+    send_image(chat[:room][:id], "./image/cat.jpg")
+  end
+end
+```
+
+## 개발
+
+
+### Hot Reload
+
+개발 중에는 `hot_reload: true` 옵션을 사용하여 파일 변경 시 자동으로 재시작할 수 있습니다:
+
+```ruby
+client = IrisRb::Client.new(
+  url: "http://localhost:3000",
+  hot_reload: true
+)
+```
+
+`.rb` 파일이 변경되면 자동으로 스크립트가 재시작됩니다.
+
+## 버전
+
+현재 버전: **0.0.1**
+
+## 라이선스
+
+이 프로젝트는 개인 프로젝트입니다.

data/lib/iris_rb/client.rb

@@ -0,0 +1,302 @@
+require 'websocket-client-simple'
+require 'net/http'
+require 'uri'
+require 'json'
+require 'logger'
+require 'listen'
+require 'open-uri'
+require 'base64'
+
+module IrisRb
+  class Client
+    def initialize(url:, hot_reload: false)
+      if url =~ %r{^https?://}
+        @http_url = url
+        @ws_url = url.sub(%r{/$}, "") + "/ws"
+      else
+        raise ArgumentError, "url must start with http:// or https://"
+      end
+      @logger = Logger.new($stdout)
+      @current_room_id = nil
+      connect_websocket
+      start_hot_reload if hot_reload
+    end
+
+    def connect_websocket
+      @ws = WebSocket::Client::Simple.connect(@ws_url)
+      client = self
+
+      @ws.on :open do
+        client.log_info("WebSocket connected")
+      end
+
+      @ws.on :message do |msg|
+        client.handle_message(msg.data)
+      end
+
+      @ws.on :error do |e|
+        client.log_error("WebSocket error: #{e.message}")
+      end
+
+      @ws.on :close do |e|
+        client.log_info("WebSocket disconnected: #{e.inspect}")
+      end
+    end
+
+    def handle_message(raw_msg)
+      parsed = parse_json(raw_msg)
+      return unless parsed
+
+      json = parsed["json"]
+      json = parse_json(json) if json.is_a?(String)
+      json ||= {}
+
+      attachment = json["attachment"]
+      attachment = parse_json(attachment) if attachment.is_a?(String)
+      attachment ||= {}
+
+      v = json["v"]
+      v = parse_json(v) if v.is_a?(String)
+      v ||= {}
+
+      chat = {
+        room: {
+          id: json["chat_id"],
+          name: parsed["room"]
+        },
+        sender: {
+          id: json["user_id"],
+          name: parsed["sender"]
+        },
+        message: {
+          id: json["id"],
+          type: json["type"],
+          content: json["message"],
+          attachment: attachment,
+          v: v
+        },
+        raw: parsed["json"]
+      }
+
+      extended_chat = extend_chat(chat)
+
+      @current_room_id = extended_chat[:room][:id]
+      $current_chat = extended_chat
+      $client = self
+      $msg = extended_chat[:message][:content].strip
+
+      Thread.new do
+        event = event_type(v)
+        case event
+        when :message
+          on_message(extended_chat) if defined?(on_message)
+        when :new_member
+          on_newmem(extended_chat) if defined?(on_newmem)
+        when :del_member
+          on_delmem(extended_chat) if defined?(on_delmem)
+        when :unknown
+          # do nothing?
+        end
+      end
+    rescue => e
+      log_error("Failed to handle message: #{e}")
+    end
+
+    def reply(message)
+      if @current_room_id.nil?
+        raise ArgumentError, "No current room ID available. Make sure a chat event has been processed first."
+      end
+      
+      send_reply(@current_room_id, message, "text")
+    end
+
+    def send_image(room_id, image_path_or_base64)
+      if File.exist?(image_path_or_base64)
+        image_base64 = image_base64(image_path_or_base64)
+        if image_base64.nil?
+          log_error("이미지 파일을 읽을 수 없습니다: #{image_path_or_base64}")
+          return nil
+        end
+        send_reply(room_id, image_base64, "image")
+      else
+        send_reply(room_id, image_path_or_base64, "image")
+      end
+    end
+
+    def send_image_multiple(room_id, image_base64s)
+      send_reply(room_id, image_base64s, "image_multiple")
+    end
+
+    def query(query_str, bind = [])
+      endpoint = URI.join(@http_url, "/query")
+      payload = { query: query_str, bind: bind }.to_json
+      headers = { "Content-Type" => "application/json" }
+
+      res = post_request(endpoint, payload, headers)
+      if res.is_a?(Net::HTTPSuccess)
+        body = JSON.parse(res.body)
+        body["data"]
+      else
+        log_error("Failed to run query: #{res.body}")
+        nil
+      end
+    rescue => e
+      log_error("Query error: #{e}")
+      nil
+    end
+
+    def log_info(msg)
+      @logger ? @logger.info(msg) : puts(msg)
+    end
+
+    def log_error(msg)
+      @logger ? @logger.error(msg) : puts(msg)
+    end
+
+    def start_hot_reload
+      current_dir = File.expand_path(File.dirname($0))
+      listener = Listen.to(current_dir, only: /\.rb$/) do |_modified, _added, _removed|
+        exec("ruby #{$0} #{ARGV.join(' ')}")
+      end
+      listener.start
+    end
+
+    private
+
+    def send_reply(room_id, data, type)
+      endpoint = URI.join(@http_url, "/reply")
+      payload = {
+        type: type,
+        room: room_id,
+        data: data
+      }.to_json
+      headers = { "Content-Type" => "application/json" }
+
+      res = post_request(endpoint, payload, headers)
+      if res.is_a?(Net::HTTPSuccess)
+        log_info("Successfully sent #{type}: #{res.code}")
+      else
+        log_error("Failed to send #{type}: #{res.body}")
+      end
+    rescue => e
+      log_error("Send #{type} error: #{e}")
+    end
+
+    def post_request(uri, payload, headers)
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = false
+      req = Net::HTTP::Post.new(uri.request_uri, headers)
+      req.body = payload
+      http.request(req)
+    end
+
+    def parse_json(str)
+      JSON.parse(str)
+    rescue JSON::ParserError
+      nil
+    end
+
+    def event_type(v_hash)
+      origin = v_hash["origin"]
+      case origin
+      when "MSG" then :message
+      when "NEWMEM" then :new_member
+      when "DELMEM" then :del_member
+      else :unknown
+      end
+    end
+
+    def extend_chat(chat)
+      extend_with_room_type(chat)
+      extend_with_member_info(chat)
+    end
+
+    def extend_with_room_type(chat)
+      query_str = "SELECT type FROM chat_rooms where id = ?"
+      room_id = chat[:room][:id]
+
+      result = query(query_str, [room_id])
+      type = result&.first&.fetch("type", "Unknown") || "Unknown"
+      chat[:room][:type] = type
+      chat
+    end
+
+    def extend_with_member_info(chat)
+      user_id = chat[:sender][:id]
+      
+      result = query("SELECT * FROM chat_logs WHERE user_id = ? ORDER BY id ASC LIMIT 1", [user_id])
+      
+      nickname = nil
+      if result && result.first
+        row = result.first
+        message = row["message"]
+        
+        if message
+          begin
+            feed = JSON.parse(message)
+            if feed && feed["feedType"] == 4
+              member = feed["members"]&.first
+              nickname = member["nickName"] if member
+            end
+          rescue JSON::ParserError
+          end
+        end
+      end
+      
+      if nickname
+        chat[:sender][:name] = nickname
+      end
+      
+      chat
+    end
+
+    public
+
+    def image_base64(image_path)
+      begin
+        if File.exist?(image_path)
+          image_data = File.binread(image_path)
+          Base64.strict_encode64(image_data)
+        else
+          nil
+        end
+      rescue => e
+        nil
+      end
+    end
+
+    private
+
+    def decrypt(enc, data, user_id)
+      endpoint = URI.join(@http_url, "/decrypt")
+      payload = { enc: enc, b64_ciphertext: data, user_id: user_id }.to_json
+      headers = { "Content-Type" => "application/json" }
+
+      res = post_request(endpoint, payload, headers)
+      if res.is_a?(Net::HTTPSuccess)
+        body = JSON.parse(res.body)
+        body["plain_text"] || data
+      else
+        log_error("Failed to decrypt: #{res.body}")
+        data
+      end
+    rescue => e
+      log_error("Decrypt error: #{e}")
+      data
+    end
+
+    public
+  end
+end
+
+def reply(message)
+  $client&.reply(message)
+end
+
+def send_image(room_id, file_path)
+  $client.send_image(room_id, file_path)
+end
+
+def msg
+  $msg
+end

data/lib/iris_rb/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module IrisRb
+  VERSION = "0.0.1"
+end

data/lib/iris_rb.rb

@@ -0,0 +1,6 @@
+require_relative "iris_rb/version"
+require_relative "iris_rb/client"
+
+module IrisRb
+  class Error < StandardError; end
+end

metadata

@@ -0,0 +1,45 @@
+--- !ruby/object:Gem::Specification
+name: iris_ruby
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- qweruby
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+description: A Ruby package that supports the Iris framework
+email:
+- qweruby8@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/iris_rb.rb
+- lib/iris_rb/client.rb
+- lib/iris_rb/version.rb
+homepage: https://github.com/Siruu580/IrisRb
+licenses:
+- MIT
+metadata: {}
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.4.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: Ruby port of Iris
+test_files: []