wikidotrb 3.0.7.pre.6

data/lib/wikidotrb/module/user.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+require "nokogiri"
+require_relative "../common/exceptions"
+require_relative "../util/requestutil"
+require_relative "../util/stringutil"
+
+module Wikidotrb
+  module Module
+    # ユーザーのコレクションを表すクラス
+    class UserCollection < Array
+      # ユーザー名のリストからユーザーオブジェクトのリストを取得する
+      # @param client [Client] クライアント
+      # @param names [Array<String>] ユーザー名のリスト
+      # @param raise_when_not_found [Boolean] ユーザーが見つからない場合に例外を送出するか
+      # @return [UserCollection] ユーザーオブジェクトのリスト
+      def self.from_names(client, names, raise_when_not_found = false)
+        urls = names.map { |name| "https://www.wikidot.com/user:info/#{Wikidotrb::Util::StringUtil.to_unix(name)}" }
+
+        responses = Wikidotrb::Util::RequestUtil.request(client: client, method: "GET", urls: urls)
+
+        users = []
+
+        responses.each do |response|
+          raise response if response.is_a?(Exception)
+
+          html = Nokogiri::HTML(response.body.to_s)
+
+          # 存在チェック
+          if html.at_css("div.error-block")
+            raise NotFoundException, "User not found: #{response.uri}" if raise_when_not_found
+
+            next
+          end
+
+          # idの取得
+          user_id = html.at_css("a.btn.btn-default.btn-xs")["href"].split("/").last.to_i
+
+          # nameの取得
+          name = html.at_css("h1.profile-title").text.strip
+
+          # avatar_urlの取得
+          avatar_url = "https://www.wikidot.com/avatar.php?userid=#{user_id}"
+
+          users << User.new(
+            client: client,
+            id: user_id,
+            name: name,
+            unix_name: Wikidotrb::Util::StringUtil.to_unix(name),
+            avatar_url: avatar_url
+          )
+        end
+
+        new(users)
+      end
+    end
+
+    # ユーザーオブジェクトの抽象クラス
+    class AbstractUser
+      attr_accessor :client, :id, :name, :unix_name, :avatar_url, :ip, :ip_masked
+
+      def initialize(client:, id: nil, name: nil, unix_name: nil, avatar_url: nil, ip: nil, ip_masked: nil)
+        @client = client
+        @id = id
+        @name = name
+        @unix_name = unix_name
+        @avatar_url = avatar_url
+        @ip = ip
+        @ip_masked = ip_masked
+      end
+    end
+
+    # 一般のユーザーオブジェクト
+    class User < AbstractUser
+      attr_accessor :client, :id, :name, :unix_name, :avatar_url, :ip
+
+      def initialize(client:, id: nil, name: nil, unix_name: nil, avatar_url: nil)
+        super
+      end
+
+      # ユーザー名からユーザーオブジェクトを取得する
+      # @param client [Client] クライアント
+      # @param name [String] ユーザー名
+      # @param raise_when_not_found [Boolean] ユーザーが見つからない場合に例外を送出するか
+      # @return [User] ユーザーオブジェクト
+      def self.from_name(client, name, raise_when_not_found = false)
+        UserCollection.from_names(client, [name], raise_when_not_found).first
+      end
+    end
+
+    # 削除されたユーザーオブジェクト
+    class DeletedUser < AbstractUser
+      def initialize(client:, id: nil)
+        super(client: client, id: id, name: "account deleted", unix_name: "account_deleted", avatar_url: nil)
+      end
+    end
+
+    # 匿名ユーザーオブジェクト
+    class AnonymousUser < AbstractUser
+      def initialize(client:, ip: nil, ip_masked: nil)
+        super(client: client, id: nil, name: "Anonymous", unix_name: "anonymous", avatar_url: nil, ip: ip, ip_masked: ip_masked)
+      end
+    end
+
+    # ゲストユーザーオブジェクト
+    class GuestUser < AbstractUser
+      def initialize(client:, name:, avatar_url:)
+        super(client: client, id: nil, name: name, unix_name: nil, avatar_url: avatar_url)
+      end
+    end
+
+    # Wikidotシステムユーザーオブジェクト
+    class WikidotUser < AbstractUser
+      def initialize(client:)
+        super(client: client, id: nil, name: "Wikidot", unix_name: "wikidot", avatar_url: nil)
+      end
+    end
+  end
+end

data/lib/wikidotrb/util/parser/odate.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require "nokogiri"
+require "time"
+
+module Wikidotrb
+  module Util
+    module Parser
+      class ODateParser
+        # odate要素を解析し、Timeオブジェクトを返す
+        # @param odate_element [Nokogiri::XML::Element] odate要素
+        # @return [Time] odate要素が表す日時
+        # @raise [ArgumentError] odate要素が有効なunix timeを含んでいない場合
+        def self.parse(odate_element)
+          # odate_elementがNokogiri::XML::Elementでない場合はその内容をパースする
+          odate_element = Nokogiri::HTML(odate_element.to_s).at_css(".odate") unless odate_element.is_a?(Nokogiri::XML::Element)
+
+          # 要素がnilの場合やclass属性がない場合はエラー
+          raise ArgumentError, "odate element does not contain a valid unix time" if odate_element.nil? || odate_element["class"].nil?
+
+          # クラス属性を取得して処理
+          odate_classes = odate_element["class"].split
+
+          # "time_"が含まれるクラスを検索
+          odate_classes.each do |odate_class|
+            # "time_"が含まれるクラスを検索
+            next unless odate_class.start_with?("time_")
+
+            unix_time_str = odate_class.sub("time_", "")
+            unix_time = unix_time_str.to_i
+
+            # unix timeが有効な範囲内か確認
+            # Wikidotは-8640000000000から8640000000000までの範囲をサポート
+            min_unix_time = -8_640_000_000_000
+            max_unix_time = 8_640_000_000_000
+            raise Wikidotrb::Common::Exceptions::UnexpectedException, "Invalid unix time" if unix_time < min_unix_time || unix_time > max_unix_time
+
+            return Time.at(unix_time)
+          end
+
+          # "time_"を含むクラスが見つからなかった場合はエラーを発生させる
+          raise ArgumentError, "odate element does not contain a valid unix time"
+        end
+      end
+    end
+  end
+end

data/lib/wikidotrb/util/parser/user.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require "nokogiri"
+require_relative "../../module/user"
+
+module Wikidotrb
+  module Util
+    module Parser
+      class UserParser
+        # printuser要素をパースし、ユーザーオブジェクトを返す
+        # @param client [Client] クライアント
+        # @param elem [Nokogiri::XML::Element] パース対象の要素（printuserクラスがついた要素）
+        # @return [AbstractUser] パースされて得られたユーザーオブジェクト
+        def self.parse(client, elem)
+          if elem.nil?
+            return nil
+          elsif deleted_user_string?(elem)
+            # Handle "(user deleted)" case
+            return Wikidotrb::Module::DeletedUser.new(client: client)
+          elsif !elem.is_a?(Nokogiri::XML::Element)
+            # Assume it is a string and parse it using Nokogiri
+            parsed_doc = Nokogiri::HTML.fragment(elem.to_s)
+            elem = parsed_doc.children.first
+          end
+
+          if elem["class"]&.include?("deleted")
+            parse_deleted_user(client, elem)
+
+          elsif elem["class"]&.include?("anonymous")
+            parse_anonymous_user(client, elem)
+
+          elsif gravatar_avatar?(elem)
+            parse_guest_user(client, elem)
+
+          elsif elem.text.strip == "Wikidot"
+            parse_wikidot_user(client)
+
+          else
+            parse_regular_user(client, elem)
+          end
+        end
+
+        private
+
+        def self.parse_deleted_user(client, elem)
+          id = elem["data-id"].to_i
+          Wikidotrb::Module::DeletedUser.new(client: client, id: id)
+        end
+
+        def self.parse_anonymous_user(client, elem)
+          masked_ip = elem.at_css("span.ip").text.gsub(/[()]/, "").strip
+          ip = masked_ip # デフォルトはマスクされたIP
+
+          # 完全なIPが取得できる場合はそちらを使用
+          if (onclick_attr = elem.at_css("a")["onclick"])
+            match_data = onclick_attr.match(/WIKIDOT.page.listeners.anonymousUserInfo\('(.+?)'\)/)
+            ip = match_data[1] if match_data
+          end
+
+          Wikidotrb::Module::AnonymousUser.new(client: client, ip: ip, ip_masked: masked_ip)
+        end
+
+        def self.parse_guest_user(client, elem)
+          guest_name = elem.text.strip.split.first
+          avatar_url = elem.at_css("img")["src"]
+          Wikidotrb::Module::GuestUser.new(client: client, name: guest_name, avatar_url: avatar_url)
+        end
+
+        def self.parse_wikidot_user(client)
+          Wikidotrb::Module::WikidotUser.new(client: client)
+        end
+
+        def self.parse_regular_user(client, elem)
+          user_anchor = elem.css("a").last
+
+          # user_anchorがnilの場合はnilを返す
+          return nil if user_anchor.nil?
+
+          user_name = user_anchor.text.strip
+          user_unix = user_anchor["href"].to_s.gsub("http://www.wikidot.com/user:info/", "")
+          user_id = user_anchor["onclick"].to_s.match(/WIKIDOT.page.listeners.userInfo\((\d+)\)/)[1].to_i
+
+          Wikidotrb::Module::User.new(
+            client: client,
+            id: user_id,
+            name: user_name,
+            unix_name: user_unix,
+            avatar_url: "http://www.wikidot.com/avatar.php?userid=#{user_id}"
+          )
+        end
+
+        def self.gravatar_avatar?(elem)
+          avatar_elem = elem.at_css("img")
+          avatar_elem && avatar_elem["src"].include?("gravatar.com")
+        end
+
+        # Check if the input is specifically the string "(user deleted)"
+        def self.deleted_user_string?(elem)
+          elem.is_a?(String) && elem.strip == "(user deleted)"
+        end
+
+      end
+    end
+  end
+end

data/lib/wikidotrb/util/quick_module.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require "httpx"
+require "json"
+
+# QMCUser構造体の定義
+QMCUser = Struct.new(:id, :name, keyword_init: true)
+
+# QMCPage構造体の定義
+QMCPage = Struct.new(:title, :unix_name, keyword_init: true)
+
+class QuickModule
+  # リクエストを送信する
+  # @param module_name [String] モジュール名
+  # @param site_id [Integer] サイトID
+  # @param query [String] クエリ
+  # @return [Hash] レスポンスのJSONパース結果
+  def self._request(module_name:, site_id:, query:)
+    # 有効なモジュール名か確認
+    raise ArgumentError, "Invalid module name" unless %w[MemberLookupQModule UserLookupQModule PageLookupQModule].include?(module_name)
+
+    # リクエストURLの構築
+    url = "https://www.wikidot.com/quickmodule.php?module=#{module_name}&s=#{site_id}&q=#{query}"
+
+    # HTTPリクエストの送信
+    response = HTTPX.get(url, timeout: { operation: 300 })
+
+    # ステータスコードのチェック
+    raise ArgumentError, "Site is not found" if response.status == 500
+
+    # JSONレスポンスのパース
+    JSON.parse(response.body.to_s)
+  end
+
+  # メンバーを検索する
+  # @param site_id [Integer] サイトID
+  # @param query [String] クエリ
+  # @return [Array<QMCUser>] ユーザーのリスト
+  def self.member_lookup(site_id:, query:)
+    users = _request(module_name: "MemberLookupQModule", site_id: site_id, query: query)["users"]
+    users.map { |user| QMCUser.new(id: user["user_id"].to_i, name: user["name"]) }
+  end
+
+  # ユーザーを検索する
+  # @param site_id [Integer] サイトID
+  # @param query [String] クエリ
+  # @return [Array<QMCUser>] ユーザーのリスト
+  def self.user_lookup(site_id:, query:)
+    users = _request(module_name: "UserLookupQModule", site_id: site_id, query: query)["users"]
+    users.map { |user| QMCUser.new(id: user["user_id"].to_i, name: user["name"]) }
+  end
+
+  # ページを検索する
+  # @param site_id [Integer] サイトID
+  # @param query [String] クエリ
+  # @return [Array<QMCPage>] ページのリスト
+  def self.page_lookup(site_id:, query:)
+    pages = _request(module_name: "PageLookupQModule", site_id: site_id, query: query)["pages"]
+    pages.map { |page| QMCPage.new(title: page["title"], unix_name: page["unix_name"]) }
+  end
+end

data/lib/wikidotrb/util/requestutil.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require "httpx"
+require "concurrent"
+
+module Wikidotrb
+  module Util
+    class RequestUtil
+      # GETリクエストを送信する
+      # @param client [Client] クライアント
+      # @param method [String] リクエストメソッド
+      # @param urls [Array<String>] URLのリスト
+      # @param return_exceptions [Boolean] 例外を返すかどうか
+      # @return [Array<HTTPX::Response, Exception>] レスポンスのリスト
+      def self.request(client:, method:, urls:, return_exceptions: false)
+        config = client.amc_client.config
+        semaphore = Concurrent::Semaphore.new(config.semaphore_limit)
+
+        # リクエスト処理を行う非同期タスク
+        tasks = urls.map do |url|
+          Concurrent::Promises.future do
+            semaphore.acquire
+
+            begin
+              case method.upcase
+              when "GET"
+                response = HTTPX.get(url)
+              when "POST"
+                response = HTTPX.post(url)
+              else
+                raise ArgumentError, "Invalid method"
+              end
+
+              response
+            rescue StandardError => e
+              e
+            ensure
+              semaphore.release
+            end
+          end
+        end
+
+        # 全てのタスクの完了を待機
+        results = Concurrent::Promises.zip(*tasks).value!
+
+        # 例外を返すかどうかのオプションに応じて結果を返す
+        return_exceptions ? results : results.each { |r| raise r if r.is_a?(Exception) }
+      end
+    end
+  end
+end

data/lib/wikidotrb/util/stringutil.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require_relative "table/char_table"
+
+module Wikidotrb
+  module Util
+    class StringUtil
+      # Unix形式に文字列を変換する
+      # @param target_str [String] 変換対象の文字列
+      # @return [String] 変換された文字列
+      def self.to_unix(target_str)
+        # MEMO: legacy wikidotの実装に合わせている
+
+        # 特殊文字の変換を行う
+        special_char_map = Wikidotrb::Table::CharTable::SPECIAL_CHAR_MAP
+        target_str = target_str.chars.map { |char| special_char_map[char] || char }.join
+
+        # lowercaseへの変換
+        target_str = target_str.downcase
+
+        # ASCII以外の文字を削除し、特殊なケースを正規表現で置き換え
+        target_str = target_str.gsub(/[^a-z0-9\-:_]/, "-")
+                               .gsub(/^_/, ":_")
+                               .gsub(/(?<!:)_/, "-")
+                               .gsub(/^-*/, "")
+                               .gsub(/-*$/, "")
+                               .gsub(/-{2,}/, "-")
+                               .gsub(/:{2,}/, ":")
+                               .gsub(":-", ":")
+                               .gsub("-:", ":")
+                               .gsub("_-", "_")
+                               .gsub("-_", "_")
+
+        # 先頭と末尾の':'を削除
+        target_str.gsub(/^:/, "").gsub(/:$/, "")
+      end
+    end
+  end
+end