obscene_gpt 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 57b6cd7a7afe7daa9400f7a24e1609c1195f96bb74d66c16bb28ef20d18ee1f0
+  data.tar.gz: d3d01454d54408acb0ebe8e97e020afb47dd49d1da39c2c5921314bb38c224c6
+SHA512:
+  metadata.gz: a76f7ba702c0bdc886f0ee805b26f72278bad23ca4f88a2e57387b342d0e213d2d93c30fce52800b0425a76b1f9ac7aa99078b6ba51d1236dc29fb18b0d84e6e
+  data.tar.gz: '08145d5400a4b29d120824e51b286be6a6d4403ef5f8ecf18d260dd68f936b01486408bc041119aa22f39f5f05f803860191fc96a0f120e13499bfcc47384ac4'

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,31 @@
+AllCops:
+  TargetRubyVersion: 3.1
+  NewCops: enable
+  SuggestExtensions: false
+
+Style/StringLiterals:
+  EnforcedStyle: double_quotes
+
+Style/StringLiteralsInInterpolation:
+  EnforcedStyle: double_quotes
+
+Style/TrailingCommaInHashLiteral:
+  EnforcedStyleForMultiline: comma
+
+Style/MutableConstant:
+  Enabled: false
+
+Style/TrailingCommaInArrayLiteral:
+  EnforcedStyleForMultiline: comma
+
+Style/TrailingCommaInArguments:
+  EnforcedStyleForMultiline: comma
+
+Style/Documentation:
+  Enabled: false
+
+Style/FrozenStringLiteralComment:
+  Enabled: false
+
+Metrics/BlockLength:
+  Enabled: false

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+## [Unreleased]
+
+## [0.1.0] - 2025-06-30
+
+- Initial release

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2025 Daniel Perez
+
+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,412 @@
+# ObsceneGpt
+
+A Ruby gem that integrates with OpenAI's API to detect whether given text contains obscene, inappropriate, or NSFW content. It provides a simple interface for content moderation using AI.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'obscene_gpt'
+```
+
+And then execute:
+
+```bash
+bundle install
+```
+
+Or install it yourself as:
+
+```bash
+gem install obscene_gpt
+```
+
+## Setup
+
+You'll need an OpenAI API key to use this gem. You can either:
+
+1. Set it as an environment variable:
+
+```bash
+export OPENAI_API_KEY="your-openai-api-key-here"
+```
+
+2. Configure it globally in your application (recommended):
+
+```ruby
+ObsceneGpt.configure do |config|
+  config.api_key = "your-openai-api-key-here"
+  config.model = "gpt-4.1-nano"
+end
+```
+
+3. Pass it directly when instantiating the detector
+
+```ruby
+detector = ObsceneGpt::Detector.new(api_key: "your-openai-api-key-here")
+```
+
+## Usage
+
+See the `examples/usage.rb` file for usage examples.
+
+### Basic Usage
+
+```ruby
+require 'obscene_gpt'
+
+# Configure once in your app initialization
+ObsceneGpt.configure do |config|
+  config.api_key = "your-openai-api-key-here"
+  config.model = "gpt-4.1-nano"
+end
+
+detector = ObsceneGpt::Detector.new
+
+result = detector.detect("Hello, how are you today?")
+puts result
+# => {"obscene" => false, "confidence" => 0.95, "reasoning" => "The text is a polite greeting with no inappropriate content.", "categories" => []}
+
+result = detector.detect("Some offensive text with BAAD words")
+puts result
+# => {"obscene" => true, "confidence" => 0.85, "reasoning" => "The text contains vulgar language with the word 'BAAD', which is likely intended as a vulgar or inappropriate term.", "categories" => ["profanity"]}
+```
+
+### ActiveModel Validator
+
+When ActiveModel is available, you can use the built-in validator to automatically check for obscene content in your models:
+
+```ruby
+class Post < ActiveRecord::Base
+  validates :content, obscene_content: true
+  validates :title, obscene_content: { message: "Title contains inappropriate language" }
+  validates :description, obscene_content: { threshold: 0.9 }
+  validates :comment, obscene_content: {
+    threshold: 0.8,
+    message: "Comment violates community guidelines"
+  }
+end
+
+# The validator automatically caches results to avoid duplicate API calls
+post = Post.new(content: "Some potentially inappropriate content")
+if post.valid?
+  puts "Post is valid"
+else
+  puts "Validation errors: #{post.errors.full_messages}"
+end
+```
+
+**Important:** The validator uses Rails caching to ensure only one API call is made per unique text content. Results are cached for 1 hour to avoid repeated API calls for the same content.
+
+## Important considerations
+
+### Cost
+
+The cost of using this gem is based on the number of API calls made.
+A very short input text will have roughly 170 tokens, and each 200 characters adds roughly another 50 tokens.
+The simple schema has 17 output tokens and the full schema has ~50 (depending on the length of the reasoning and the attributes).
+Using the simple schema and with an average of 200 chars per request, the cost (with the gpt-4.1-nano model) is roughly $1 per 35,000 requests.
+
+### Rate limits
+
+The OpenAI API has rate limits that depends on the model you are using.
+The gpt-4.1-nano model has a rate limit of 500 requests per minute with a normal paid subscription.
+
+### Latency
+
+Calling an API will obviously add some latency to your application.
+The latency is dependent on the model you are using and the length of the text you are analyzing.
+We do not recommend using this gem in latency-sensitive application.
+
+## API Reference
+
+### Configuration
+
+#### ObsceneGpt.configure(&block)
+
+Configure the gem globally.
+
+```ruby
+ObsceneGpt.configure do |config|
+  config.api_key = "your-api-key"
+  config.model = "gpt-4.1-nano"
+  config.schema = ObsceneGpt::Prompts::SIMPLE_SCHEMA
+  config.prompt = ObsceneGpt::Prompts::SYSTEM_PROMPT
+end
+```
+
+#### ObsceneGpt.configuration
+
+Get the current configuration object.
+
+### ObsceneGpt::Detector
+
+#### ObsceneGpt::Detector.new(api_key: nil, model: nil)
+
+Creates a new detector instance.
+
+#### ObsceneGpt::Detector#detect(text)
+
+Detects whether the given text contains obscene content.
+
+**Parameters:**
+
+- `text` (String): Text to analyze.
+
+**Returns:** Hash with detection results. See `Response Format` for more details.
+
+**Raises:**
+
+- `ObsceneGpt::Error`: If there's an OpenAI API error
+
+#### ObsceneGpt::Detector#detect_many(texts)
+
+Detects whether the given texts contain obscene content.
+
+**Parameters:**
+
+- `texts` (Array<String>): Texts to analyze.
+
+**Returns:** Array of hashes with detection results. See `Response Format` for more details.
+
+**Raises:**
+
+- `ObsceneGpt::Error`: If there's an OpenAI API error
+
+## Response Format
+
+The detection methods return a hash (or array of hashes) with the following structure:
+
+```ruby
+{
+  obscene: true,                    # Boolean: whether content is inappropriate
+  confidence: 0.85,                # Float: confidence score (0.0-1.0)
+  reasoning: "Contains explicit language and profanity",
+  categories: ["profanity", "explicit"]  # Array of detected categories (["sexual", "profanity", "hate", "violent", "other"])
+}
+```
+
+## Configuration Options
+
+### Default options
+
+The default configuration is:
+
+```ruby
+config.api_key = ENV["OPENAI_API_KEY"]
+config.model = "gpt-4.1-nano"
+config.schema = ObsceneGpt::Prompts::SIMPLE_SCHEMA
+config.prompt = ObsceneGpt::Prompts::SYSTEM_PROMPT
+config.test_mode = false
+config.test_detector_class = ObsceneGpt::TestDetector
+```
+
+### Test Mode
+
+To avoid making API calls during testing, you can enable test mode:
+
+```ruby
+ObsceneGpt.configure do |config|
+  config.test_mode = true
+end
+```
+
+When test mode is enabled, the detector will return mock responses based on simple pattern matching instead of making actual API calls. This is useful for:
+
+- Running tests without API costs
+- Faster test execution
+- Avoiding rate limits during development
+
+**Note:** Test mode uses basic pattern matching and is not as accurate as the actual AI model. It's intended for testing purposes only.
+
+#### Custom Test Detectors
+
+You can also configure a custom test detector class for more sophisticated test behavior:
+
+```ruby
+class MyCustomTestDetector
+  attr_reader :schema
+
+  def initialize(schema: nil)
+    @schema = schema || ObsceneGpt::Prompts::SIMPLE_SCHEMA
+  end
+
+  def detect_many(texts)
+    texts.map do |text|
+      {
+        obscene: text.include?("bad_word"),
+        confidence: 0.9
+      }
+    end
+  end
+
+  def detect(text)
+    detect_many([text])[0]
+  end
+end
+
+ObsceneGpt.configure do |config|
+  config.test_mode = true
+  config.test_detector_class = MyCustomTestDetector
+end
+```
+
+Custom test detectors must implement:
+
+- `#initialize(schema: nil)` - Accepts an optional schema parameter
+- `#detect_many(texts)` - Returns an array of result hashes
+
+See `examples/custom_test_detector.rb` for more examples.
+
+### Model
+
+We recommend using the `gpt-4.1-nano` model for cost efficiency.
+Given the simplicity of the task, it's typically not necessary to use a more expensive model.
+
+See [OpenAI's documentation](https://platform.openai.com/docs/pricing) for more information.
+
+### Prompt
+
+The system prompt can be found in `lib/obscene_gpt/prompts.rb`.
+This is a basic prompt that can be used to detect obscene content.
+You can use a custom prompt if you need to by setting the `prompt` option in the configuration.
+
+### Schema
+
+This library uses a JSON schema to enforce the response from the OpenAI API.
+There are two schemas available:
+
+- `ObsceneGpt::Prompts::SIMPLE_SCHEMA`: A simple schema that only includes the `obscene` and `confidence` fields.
+- `ObsceneGpt::Prompts::FULL_SCHEMA`: A full schema that includes the `obscene`, `confidence`, `reasoning`, and `categories` fields.
+
+You can use a custom schema if you need to by setting the `schema` option in the configuration.
+
+### Configuration Precedence
+
+1. Explicit parameters passed to methods
+2. Global configuration
+3. Environment variables (for API key only)
+
+## ActiveModel Integration
+
+The `ObsceneContentValidator` is available when ActiveModel is loaded.
+`active_model` needs to be required before obscene_gpt.
+
+### Usage
+
+```ruby
+class Post < ActiveRecord::Base
+  validates :content, :title, :description, obscene_content: true
+end
+```
+
+**Note**: Each instance of this validator will make a request to the OpenAI API.
+Therefore, it is recommended to pass all the attributes you want to check to the validator at once as shown above.
+
+### Options
+
+- `threshold` (Float): Custom confidence threshold (0.0-1.0) for determining when content is considered inappropriate. Default: Uses `ObsceneGpt.configuration.profanity_threshold`
+- `message` (String): Custom error message to display when validation fails. Default: Uses AI reasoning if available, otherwise "contains inappropriate content"
+
+### Per-Attribute Options
+
+You can also configure different options for different attributes in a single validation call:
+
+```ruby
+class Post < ActiveRecord::Base
+  validates :title, :content, obscene_content: {
+    title: { threshold: 0.8, message: "Title is too inappropriate" },
+    content: { threshold: 0.7, message: "Content needs moderation" }
+  }
+end
+```
+
+### Configuration Precedence
+
+The validator uses the following precedence for options:
+
+**Threshold:**
+
+1. Per-attribute option (e.g., `title: { threshold: 0.8 }`)
+2. Validator option (e.g., `threshold: 0.8`)
+3. Configuration default (`ObsceneGpt.configuration.profanity_threshold`)
+
+**Message:**
+
+1. Per-attribute message (e.g., `title: { message: "..." }`)
+2. Global message (e.g., `message: "..."`)
+3. AI reasoning (if available, only when schema is `ObsceneGpt::Prompts::FULL_SCHEMA`)
+4. Default message ("contains inappropriate content")
+
+### Examples
+
+**Basic validation:**
+
+```ruby
+class Post < ActiveRecord::Base
+  validates :content, obscene_content: true
+end
+```
+
+**With custom message:**
+
+```ruby
+class Post < ActiveRecord::Base
+  validates :title, obscene_content: { message: "Title contains inappropriate content" }
+end
+```
+
+**With custom threshold:**
+
+```ruby
+class Post < ActiveRecord::Base
+  validates :description, obscene_content: { threshold: 0.9 }
+end
+```
+
+**With both custom threshold and message:**
+
+```ruby
+class Post < ActiveRecord::Base
+  validates :comment, obscene_content: {
+    threshold: 0.8,
+    message: "Comment violates community guidelines"
+  }
+end
+```
+
+**Per-attribute configuration:**
+
+```ruby
+class Post < ActiveRecord::Base
+  validates :title, :content, obscene_content: {
+    title: { threshold: 0.8, message: "Title is too inappropriate" },
+    content: { threshold: 0.7, message: "Content needs moderation" }
+  }
+end
+```
+
+**Mixed global and per-attribute options:**
+
+```ruby
+class Post < ActiveRecord::Base
+  validates :title, :content, obscene_content: {
+    threshold: 0.8,  # Global threshold
+    message: "Contains inappropriate content",  # Global message
+    title: { threshold: 0.9 }  # Override threshold for title only
+  }
+end
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/danhper/obscene_gpt.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new
+
+task default: %i[spec rubocop]

data/examples/usage.rb

@@ -0,0 +1,42 @@
+require "obscene_gpt"
+
+# Configure the gem globally (do this once in your app initialization)
+ObsceneGpt.configure do |config|
+  # config.api_key = "your-openai-api-key-here"
+  config.model = "gpt-4.1-nano"
+  config.schema = ObsceneGpt::Prompts::FULL_SCHEMA
+end
+
+detector = ObsceneGpt::Detector.new
+
+texts_to_analyze = [
+  "Hello, how are you today?",
+  "This is a beautiful day!",
+  "I love programming in Ruby.",
+  "Some potentially inappropriate content here...",
+  "This text contains explicit language and should be flagged.",
+]
+
+detector.detect_many(texts_to_analyze).each_with_index do |result, index|
+  puts "Text: #{texts_to_analyze[index]}"
+  puts "Obscene: #{result[:obscene]}"
+  puts "Confidence: #{result[:confidence]}"
+  puts "Reasoning: #{result[:reasoning]}"
+  puts "Categories: #{result[:categories]}"
+  puts "--------------------------------"
+end
+
+if defined?(ActiveRecord)
+  class Post < ActiveRecord::Base
+    validates :title, :content, obscene_content: {
+      title: { message: "Title contains inappropriate language" },
+    }
+  end
+
+  post = Post.new(title: "Some normal content", content: "Some very inappropriate content")
+  if post.valid?
+    puts "Post is valid"
+  else
+    puts "Validation errors: #{post.errors.full_messages}"
+  end
+end

data/lib/obscene_gpt/active_model.rb

@@ -0,0 +1,45 @@
+begin
+  require "active_model"
+rescue LoadError
+  # do nothing
+end
+
+if defined?(ActiveModel)
+  class ObsceneContentValidator < ActiveModel::EachValidator
+    def validate(record)
+      to_validate = compute_attributes_to_validate(record)
+      return if to_validate.empty?
+
+      results = ObsceneGpt.detect_many(to_validate.values)
+      format_errors(record, to_validate, results)
+    end
+
+    private
+
+    def compute_attributes_to_validate(record)
+      attributes.map do |attribute|
+        value = record.read_attribute_for_validation(attribute)
+        next if value.nil? || value.blank?
+
+        [attribute, prepare_value_for_validation(value, record, attribute)]
+      end.compact.to_h
+    end
+
+    def format_errors(record, to_validate, results)
+      results.each_with_index do |result, index|
+        attribute = to_validate.keys[index]
+        threshold = option_for(:threshold, attribute, ObsceneGpt.configuration.profanity_threshold)
+
+        if result[:obscene] && result[:confidence] >= threshold
+          message = option_for(:message, attribute, result[:reasoning] || "contains inappropriate content")
+          record.errors.add(attribute, :obscene_content, message: message)
+        end
+      end
+    end
+
+    def option_for(key, attribute, default = nil)
+      (options[attribute] && options[attribute][key]) ||
+        options[key] || default
+    end
+  end
+end

data/lib/obscene_gpt/configuration.rb

@@ -0,0 +1,25 @@
+module ObsceneGpt
+  class << self
+    def configure
+      yield(configuration)
+    end
+
+    def configuration
+      @configuration ||= Configuration.new
+    end
+  end
+
+  class Configuration
+    attr_accessor :api_key, :model, :schema, :prompt, :profanity_threshold, :test_mode, :test_detector_class
+
+    def initialize
+      @api_key = ENV.fetch("OPENAI_API_KEY", nil)
+      @model = "gpt-4.1-nano"
+      @prompt = Prompts::SYSTEM_PROMPT
+      @schema = Prompts::SIMPLE_SCHEMA
+      @profanity_threshold = 0.8
+      @test_mode = false
+      @test_detector_class = TestDetector
+    end
+  end
+end

data/lib/obscene_gpt/detector.rb

@@ -0,0 +1,75 @@
+require "json"
+require "openai"
+
+module ObsceneGpt
+  class Detector
+    attr_reader :client, :model, :schema, :prompt
+
+    def initialize(api_key: nil, model: nil, schema: nil, prompt: nil)
+      api_key ||= ObsceneGpt.configuration.api_key
+
+      @client = OpenAI::Client.new(access_token: api_key)
+      @model = model || ObsceneGpt.configuration.model
+      @schema = schema || ObsceneGpt.configuration.schema
+      @prompt = prompt || ObsceneGpt.configuration.prompt
+    end
+
+    # Detects whether the given texts contain obscene content
+    # @param texts [Array<String>] The texts to analyze
+    # @return [Array<Hash>] An array of hashes containing the detection result with keys:
+    #   - :obscene [Boolean] Whether the text contains obscene content
+    #   - :confidence [Float] Confidence score (0.0 to 1.0)
+    #   - :reasoning [String] Explanation for the classification (only for full schema)
+    #   - :categories [Array<String>] Categories of inappropriate content found (only for full schema)
+    def detect_many(texts)
+      if ObsceneGpt.configuration.test_mode
+        test_detector = ObsceneGpt.configuration.test_detector_class.new(schema: @schema)
+        return test_detector.detect_many(texts)
+      end
+
+      run_detect_many(texts)
+    end
+
+    # Detects whether the given text contains obscene content
+    # See #detect_many for more details
+    def detect(text)
+      detect_many([text])[0]
+    end
+
+    private
+
+    def run_detect_many(texts)
+      response = @client.responses.create(parameters: make_query(texts))
+
+      JSON.parse(response.dig("output", 0, "content", 0, "text"))["results"].map { |r| r.transform_keys(&:to_sym) }
+    rescue OpenAI::Error, Faraday::Error => e
+      body = e.respond_to?(:response) ? e.response[:body] : ""
+      raise ObsceneGpt::Error, "OpenAI API error: #{e.message}\n#{body}"
+    end
+
+    def make_query(texts)
+      text_format = { name: "content-moderation", type: "json_schema", schema: make_schema(texts.length), strict: true }
+      {
+        model: @model,
+        text: { format: text_format },
+        input: [{
+          role: "user",
+          content: [{ type: "input_text", text: @prompt },
+                    { type: "input_text", text: JSON.dump(texts) }],
+        }],
+      }
+    end
+
+    def make_schema(texts_count)
+      array_schema = { type: "array", items: @schema, minItems: texts_count, maxItems: texts_count }
+      {
+        type: "object",
+        properties: {
+          results: array_schema,
+        },
+        required: %w[results],
+        additionalProperties: false,
+      }
+    end
+  end
+end

data/lib/obscene_gpt/prompts.rb

@@ -0,0 +1,52 @@
+module ObsceneGpt
+  module Prompts
+    SYSTEM_PROMPT = <<~PROMPT.freeze
+      You are a content moderation AI that analyzes texts for obscene, inappropriate, or NSFW content.
+
+      Your task is to determine if the given text contains:
+      - Explicit sexual content
+      - Profanity or vulgar language
+      - Hate speech or discriminatory language
+      - Violent or graphic content
+      - Other inappropriate material
+
+      You will be given a JSON array of texts.
+      You will need to analyze each text and determine if it contains any of the above content.
+    PROMPT
+
+    SIMPLE_SCHEMA = {
+      type: "object",
+      properties: {
+        obscene: {
+          type: "boolean",
+          description: "Whether the text contains obscene content",
+        },
+        confidence: {
+          type: "number",
+          minimum: 0,
+          maximum: 1,
+          description: "A confidence score between 0 and 1",
+        },
+      },
+      required: %w[obscene confidence],
+      additionalProperties: false,
+    }.freeze
+
+    FULL_SCHEMA = {
+      type: "object",
+      properties: SIMPLE_SCHEMA[:properties].merge(
+        reasoning: {
+          type: "string",
+          description: "A reasoning for the classification",
+        },
+        categories: {
+          type: "array",
+          items: { type: "string", enum: %w[sexual profanity hate violent other] },
+          description: "A list of categories that the text belongs to",
+        },
+      ),
+      required: %w[obscene confidence reasoning categories],
+      additionalProperties: false,
+    }.freeze
+  end
+end

data/lib/obscene_gpt/test_detector.rb

@@ -0,0 +1,56 @@
+module ObsceneGpt
+  class TestDetector
+    attr_reader :schema
+
+    def initialize(schema: nil)
+      @schema = schema || ObsceneGpt::Prompts::SIMPLE_SCHEMA
+    end
+
+    # Detects whether the given texts contain obscene content using test mode
+    # @param texts [Array<String>] The texts to analyze
+    # @return [Array<Hash>] An array of hashes containing the detection result
+    def detect_many(texts) # rubocop:disable Metrics/MethodLength
+      texts.map do |text|
+        # Simple heuristic for test mode: detect common profanity patterns
+        is_obscene = detect_obscene_patterns(text)
+        confidence = is_obscene ? 0.85 : 0.95
+
+        result = {
+          obscene: is_obscene,
+          confidence: confidence,
+        }
+
+        # Add additional fields if using full schema
+        if @schema == Prompts::FULL_SCHEMA
+          result[:reasoning] = is_obscene ? "Contains inappropriate content" : "Clean text"
+          result[:categories] = is_obscene ? ["profanity"] : []
+        end
+
+        result
+      end
+    end
+
+    # Detects whether the given text contains obscene content
+    # @param text [String] The text to analyze
+    # @return [Hash] Detection result
+    def detect(text)
+      detect_many([text])[0]
+    end
+
+    private
+
+    def detect_obscene_patterns(text)
+      # Simple pattern matching for test mode
+      # This is just for testing - not meant to be comprehensive
+      profanity_patterns = [
+        /\b(fuck|fucked|fucking|shit|bitch|ass|damn|hell)\b/i,
+        /\b(sex|porn|nude|naked)\b/i,
+        /\b(kill|murder|death|blood)\b/i,
+        /\b(hate|racist|sexist)\b/i,
+        /\b(gore)\b/i,
+      ]
+
+      profanity_patterns.any? { |pattern| text.match?(pattern) }
+    end
+  end
+end

data/lib/obscene_gpt/version.rb

@@ -0,0 +1,3 @@
+module ObsceneGpt
+  VERSION = "0.1.0"
+end

data/lib/obscene_gpt.rb

@@ -0,0 +1,20 @@
+require_relative "obscene_gpt/version"
+require_relative "obscene_gpt/prompts"
+require_relative "obscene_gpt/configuration"
+require_relative "obscene_gpt/test_detector"
+require_relative "obscene_gpt/detector"
+require_relative "obscene_gpt/active_model"
+
+module ObsceneGpt
+  class Error < StandardError; end
+
+  class << self
+    def detect_many(texts)
+      ObsceneGpt::Detector.new.detect_many(texts)
+    end
+
+    def detect(text)
+      ObsceneGpt::Detector.new.detect(text)
+    end
+  end
+end

data/sig/obscene_gpt.rbs

@@ -0,0 +1,4 @@
+module ObsceneGpt
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

metadata

@@ -0,0 +1,75 @@
+--- !ruby/object:Gem::Specification
+name: obscene_gpt
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Daniel Perez
+bindir: exe
+cert_chain: []
+date: 2025-06-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ruby-openai
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '8.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '8.1'
+description: ObsceneGpt is a Ruby gem that integrates with OpenAI's API to detect
+  whether given text contains obscene, inappropriate, or NSFW content. It provides
+  a simple interface for content moderation using AI.
+email:
+- daniel@perez.sh
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec"
+- ".rubocop.yml"
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- examples/usage.rb
+- lib/obscene_gpt.rb
+- lib/obscene_gpt/active_model.rb
+- lib/obscene_gpt/configuration.rb
+- lib/obscene_gpt/detector.rb
+- lib/obscene_gpt/prompts.rb
+- lib/obscene_gpt/test_detector.rb
+- lib/obscene_gpt/version.rb
+- sig/obscene_gpt.rbs
+homepage: https://github.com/danhper/obscene-gpt
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/danhper/obscene-gpt
+  changelog_uri: https://github.com/danhper/obscene-gpt/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.2
+specification_version: 4
+summary: A Ruby gem that uses OpenAI API to detect obscene content in text
+test_files: []