joliegg 0.1.0

data/lib/jolie/moderation/result.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Jolie
+  module Moderation
+    # One detected moderation category, mirroring the TS package's
+    # { category, confidence } entries, plus the list entry that matched when
+    # the source is one of the bundled lists (nil for API-backed categories).
+    Category = Struct.new(:category, :confidence, :matched)
+
+    # The outcome of moderating one input, mirroring the TS package's
+    # ModerationResult: the original source plus every category detected on it.
+    Result = Struct.new(:source, :moderation) do
+      def flagged?
+        moderation.any?
+      end
+
+      def categories
+        moderation.map(&:category)
+      end
+    end
+  end
+end

data/lib/jolie/moderation/url_blocklist.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Jolie
+  module Moderation
+    # Domain blocklist and URL-shortener list extracted from the
+    # @joliegg/moderation TypeScript package: data/url_blacklist.json and
+    # data/url_shorteners.json are verbatim copies of that repo's
+    # src/url-blacklist.json / src/url-shorteners.json (run
+    # `rake "data:sync[/path/to/moderation]"` to refresh them).
+    #
+    # Matching mirrors ModerationClient#moderateLink: an input (full URL, bare
+    # domain, or email address) is reduced to its host, then every domain
+    # suffix is checked against the set — a listed "example.com" also blocks
+    # "sub.example.com", and an email at either address is blocked. Unlike the
+    # TS package's exact-match shortener check, shorteners are suffix-matched
+    # too, so "links.bit.ly" is recognized when "bit.ly" is listed.
+    module UrlBlocklist
+      DATA_DIR = File.expand_path("../../../data", __dir__).freeze
+      BLOCKLIST_PATH = File.join(DATA_DIR, "url_blacklist.json").freeze
+      SHORTENERS_PATH = File.join(DATA_DIR, "url_shorteners.json").freeze
+
+      module_function
+
+      # True when the input's host (or any parent domain of it) is blocklisted.
+      def blocked?(input)
+        !match(input).nil?
+      end
+
+      # The blocklist entry that matched the input's host, or nil.
+      def match(input)
+        find_in(blocklist, input)
+      end
+
+      # True when the input's host is (or belongs to) a listed URL shortener.
+      def shortener?(input)
+        !matched_shortener(input).nil?
+      end
+
+      # The shortener-list entry that matched the input's host, or nil.
+      def matched_shortener(input)
+        find_in(shorteners, input)
+      end
+
+      # Reduces a URL, bare domain, or email address to a bare lowercase host:
+      #   "User@Sub.Example.COM"          -> "sub.example.com"
+      #   "HTTPS://example.com:8080/a?b"  -> "example.com"
+      #   "a/b@mailinator.com"            -> "mailinator.com"
+      #   "example.com."                  -> "example.com"
+      # Returns "" when nothing host-like can be extracted. IP literals pass
+      # through unchanged (the lists hold domains, so they simply never match).
+      #
+      # A schemeless input containing @ is treated as an email address FIRST:
+      # the local part may legally contain / ? # (RFC 5322 atext), so applying
+      # URL delimiters to it would sever the domain ("a/b@mailinator.com" would
+      # otherwise read as host "a"). The host is everything after the LAST @.
+      #
+      # With a scheme:// present it's a URL: the authority is isolated BEFORE
+      # any @ handling, so an @ in the path/query/fragment
+      # ("/redirect?to=user@mailinator.com") is never mistaken for userinfo,
+      # and only the LAST @ within the authority is the userinfo delimiter (per
+      # RFC 3986), so "example.com@evil.example" still resolves to
+      # "evil.example".
+      def extract_host(input)
+        candidate = input.to_s.strip.downcase
+
+        if !candidate.match?(%r{\A[a-z][a-z0-9+.-]*://}) && candidate.include?("@")
+          return candidate.split("@").last.to_s.sub(/:\d*\z/, "").sub(/\.\z/, "")
+        end
+
+        candidate = candidate.sub(%r{\A[a-z][a-z0-9+.-]*://}, "") # scheme
+        candidate = candidate.split(%r{[/\\?#]}).first.to_s # authority: cut path/query/fragment
+        candidate = candidate.split("@").last.to_s # URL userinfo
+        candidate = candidate.sub(/:\d*\z/, "") # port
+        candidate.sub(/\.\z/, "") # trailing root dot
+      end
+
+      def blocklist
+        @blocklist ||= load_set(BLOCKLIST_PATH)
+      end
+
+      def shorteners
+        @shorteners ||= load_set(SHORTENERS_PATH)
+      end
+
+      def blocklist_size
+        blocklist.size
+      end
+
+      def shortener_size
+        shorteners.size
+      end
+
+      # Drops the memoized sets so the next check re-reads the data files.
+      def reload!
+        @blocklist = nil
+        @shorteners = nil
+      end
+
+      def find_in(set, input)
+        host = extract_host(input)
+        return nil if host.empty?
+
+        parts = host.split(".")
+        (parts.length - 1).downto(0) do |index|
+          suffix = parts[index..].join(".")
+          return suffix if set.include?(suffix)
+        end
+        nil
+      end
+
+      def load_set(path)
+        Set.new(JSON.parse(File.read(path)))
+      end
+    end
+  end
+end

data/lib/jolie/moderation.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require_relative "moderation/result"
+require_relative "moderation/url_blocklist"
+
+module Jolie
+  # Ruby counterpart of the @joliegg/moderation TypeScript package. The URL
+  # blocklist is the first capability ported; text/image/audio moderation can
+  # follow under this same namespace.
+  module Moderation
+    module_function
+
+    # Checks a link against the bundled lists, mirroring the TS
+    # ModerationClient#moderateLink list checks (without the Google WebRisk
+    # lookup). Returns a Result whose moderation categories are "BLACK_LIST"
+    # for a blocklisted host and "URL_SHORTENER" for a shortener host; a
+    # shortener is only reported when allow_shorteners is false, and a
+    # blocklisted host is reported even when it is also a shortener.
+    def moderate_link(url, allow_shorteners: false)
+      moderation = []
+
+      if (matched = UrlBlocklist.match(url))
+        moderation << Category.new(category: "BLACK_LIST", confidence: 100, matched: matched)
+      elsif !allow_shorteners && (matched = UrlBlocklist.matched_shortener(url))
+        moderation << Category.new(category: "URL_SHORTENER", confidence: 100, matched: matched)
+      end
+
+      Result.new(source: url, moderation: moderation)
+    end
+
+    # True when moderate_link flags the link for any category.
+    def link_blocked?(url, allow_shorteners: false)
+      moderate_link(url, allow_shorteners: allow_shorteners).flagged?
+    end
+  end
+end

data/lib/jolie/version.rb

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

data/lib/jolie.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require_relative "jolie/version"
+require_relative "jolie/moderation"
+
+# Top-level namespace for the Jolie libraries. Moderation is the first
+# capability; others can live under this module alongside it.
+module Jolie
+end

data/lib/joliegg.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require "jolie"

metadata

@@ -0,0 +1,51 @@
+--- !ruby/object:Gem::Specification
+name: joliegg
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Diana Islas Ocampo
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+description: Jolie's Ruby libraries
+email: dev@hyuchia.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.md
+- README.md
+- data/url_blacklist.json
+- data/url_shorteners.json
+- lib/jolie.rb
+- lib/jolie/moderation.rb
+- lib/jolie/moderation/result.rb
+- lib/jolie/moderation/url_blocklist.rb
+- lib/jolie/version.rb
+- lib/joliegg.rb
+homepage: https://github.com/joliegg/gem
+licenses:
+- Nonstandard
+metadata:
+  source_code_uri: https://github.com/joliegg/gem
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.4'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: Jolie's Ruby toolkit
+test_files: []