obscenity-plus 1.0.6 → 1.0.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f14babd302429e64ca0ff4629e1e90de5dcad54ba5752e101a24ae2773514ea0
-  data.tar.gz: 64afe5a4528f0624aa7935674ade1add0cc9402aa26896624879b36a2dc7e4b3
+  metadata.gz: 964e39e6cc5f091523fa547126151189c1c4e031629a60cdb89a1caf0294935a
+  data.tar.gz: d35c0646dadbd02e1e8d6ad76268f69d8356744a84a5cb239611a825020389dc
 SHA512:
-  metadata.gz: d25a93885b8dc75a132724568b6478c7fffcec50e5a16bdb9908f05c167d7025a08a5edb5d4ef2665dc7dc5411580478ac54745155208c75e5d5e9705ff22ed6
-  data.tar.gz: e13bd250bfd7463bb5bd902a675064e71c561ac1899bb563d7606928bc1ca55baf5dc27f0d25d2673e009482f2f7265fe5f016782f9dfa500d5604bc7478d8cf
+  metadata.gz: 076fc08ca6d19e0026199daccbff840c9750836d4a63b6b4d17b836f7debefd10a33151a6be41f82b8a726a6993ebc0cd60fce5a8fee7593be7e2cb28d241700
+  data.tar.gz: e6d4d7f9ed48663414e7a1e1ff5377230895234454171a5c6d9791f8a2488c26da21ccab2684916f4864bfd181eeb9b961f07514381741de9d7ef94b8807c03f

data/lib/obscenity/config.rb

@@ -1,51 +1,49 @@
 module Obscenity
+  DEFAULT_BLACKLIST = ["badword"] # Ensure this is not empty
+  DEFAULT_WHITELIST = []
+
   class Config
-    
-    attr_accessor :replacement
-    
-    DEFAULT_WHITELIST = []
-    DEFAULT_BLACKLIST = File.expand_path("../../config/blacklist.yml", __dir__)
-    
+    attr_accessor :replacement, :blacklist, :whitelist
+
     def initialize
-      yield(self) if block_given?
+      puts "DEBUG: Initializing Config with DEFAULT_BLACKLIST: #{DEFAULT_BLACKLIST.inspect}"
+      @blacklist ||= DEFAULT_BLACKLIST.dup
+      @whitelist ||= DEFAULT_WHITELIST.dup
+      @replacement ||= :stars
       validate_config_options
     end
     
-    def replacement
-      @replacement ||= :garbled
-    end
-    
-    def blacklist
-      @blacklist ||= DEFAULT_BLACKLIST
-    end
-    
     def blacklist=(value)
-      @blacklist = value == :default ? DEFAULT_BLACKLIST : value
+      raise ArgumentError, "Blacklist cannot be empty" if value.nil? || value.empty?
+      puts "DEBUG: Setting blacklist to: #{value.inspect}"
+      @blacklist = value
     end
-    
-    def whitelist
-      @whitelist ||= DEFAULT_WHITELIST
-    end
-    
-    def whitelist=(value)
-      @whitelist = value == :default ? DEFAULT_WHITELIST : value
-    end
-    
+
     private
+
     def validate_config_options
-      [@blacklist, @whitelist].each{ |content| validate_list_content(content) if content }
+      [@blacklist, @whitelist].each do |content|
+        next if content.nil? || content.empty? # Skip validation for empty whitelist
+        validate_list_content(content)
+      end
     end
     
+
     def validate_list_content(content)
+      puts "DEBUG: Validating content: #{content.inspect}"
       case content
-      when Array    then !content.empty?       || raise(Obscenity::EmptyContentList.new('Content array is empty.'))
-      when String   then File.exist?(content) || raise(Obscenity::UnkownContentFile.new("Content file can't be found."))
-      when Pathname then content.exist?        || raise(Obscenity::UnkownContentFile.new("Content file can't be found."))
-      when Symbol   then content == :default   || raise(Obscenity::UnkownContent.new("The only accepted symbol is :default."))
+      when Array
+        raise Obscenity::EmptyContentList.new('Content array is empty.') if content.empty?
+      when String
+        raise Obscenity::UnkownContentFile.new("Content file can't be found.") unless File.exist?(content)
+      when Pathname
+        raise Obscenity::UnkownContentFile.new("Content file can't be found.") unless content.exist?
+      when Symbol
+        raise Obscenity::UnkownContent.new("The only accepted symbol is :default.") unless content == :default
       else
-        raise Obscenity::UnkownContent.new("The content can be either an Array, Pathname, or String path to a .yml file.")
+        raise Obscenity::UnkownContent.new("The content can be an Array, Pathname, or String path to a .yml file.")
       end
     end
     
   end
-end
+end

data/lib/obscenity.rb

@@ -1,3 +1,4 @@
+# obscenity/lib/obscenity.rb
 require 'obscenity/error'
 require 'obscenity/config'
 require 'obscenity/base'
@@ -34,7 +35,5 @@ module Obscenity extend self
   def offensive(text)
     Obscenity::Base.offensive(text)
   end
-  
-  
 end
   

data/spec/active_model_spec.rb

@@ -0,0 +1,98 @@
+#active_model_spec.rb
+require 'spec_helper'
+require 'active_model'
+require 'obscenity'
+require 'obscenity/active_model'
+
+RSpec.describe "ActiveModel Obscenity Validation" do
+  before do
+    Obscenity.configure do |config|
+      config.blacklist = ["shits"]
+      config.replacement = :stars
+    end
+  end
+
+  let(:generate_new_class) do
+    ->(name, options = {}) do
+      klass_name = "Dummy::#{name}"
+      Object.send(:remove_const, klass_name) if Object.const_defined?(klass_name)
+      Class.new do
+        include ActiveModel::Validations
+        attr_accessor :title
+
+        validates :title, options
+
+        def initialize(attributes = {})
+          attributes.each { |key, value| send("#{key}=", value) }
+        end
+      end
+    end
+  end
+
+  context "when title is profane" do
+    it "is invalid and adds an error message" do
+      klass = generate_new_class.call("Post", obscenity: true)
+      post = klass.new(title: "He who poops, shits itself")
+
+      expect(post.valid?).to be false
+      expect(post.errors).to have_key(:title)
+      expect(post.errors[:title]).to include("cannot be profane")
+    end
+
+    it "includes a custom error message for profanity" do
+      klass = generate_new_class.call("Post", obscenity: { message: "can't be profane!" })
+      post = klass.new(title: "He who poops, shits itself")
+
+      expect(post.valid?).to be false
+      expect(post.errors).to have_key(:title)
+      expect(post.errors[:title]).to include("can't be profane!")
+    end
+  end
+
+  context "when sanitizing the title" do
+    it "uses the default replacement method" do
+      klass = generate_new_class.call("Post", obscenity: { sanitize: true })
+      post = klass.new(title: "He who poops, shits itself")
+
+      expect(post.valid?).to be true
+      expect(post.errors).not_to have_key(:title)
+      expect(post.title).to eq("He who poops, ***** itself")
+    end
+
+    it "uses the :garbled replacement method" do
+      klass = generate_new_class.call("Post", obscenity: { sanitize: true, replacement: :garbled })
+      post = klass.new(title: "He who poops, shits itself")
+
+      expect(post.valid?).to be true
+      expect(post.errors).not_to have_key(:title)
+      expect(post.title).to eq("He who poops, $@!#% itself")
+    end
+
+    it "uses the :stars replacement method" do
+      klass = generate_new_class.call("Post", obscenity: { sanitize: true, replacement: :stars })
+      post = klass.new(title: "He who poops, shits itself")
+
+      expect(post.valid?).to be true
+      expect(post.errors).not_to have_key(:title)
+      expect(post.title).to eq("He who poops, ***** itself")
+    end
+
+    it "uses the :vowels replacement method" do
+      klass = generate_new_class.call("Post", obscenity: { sanitize: true, replacement: :vowels })
+      post = klass.new(title: "He who poops, shits itself")
+
+      expect(post.valid?).to be true
+      expect(post.errors).not_to have_key(:title)
+      expect(post.title).to eq("He who poops, sh*ts itself")
+    end
+
+    it "uses a custom replacement string" do
+      klass = generate_new_class.call("Post", obscenity: { sanitize: true, replacement: "[censored]" })
+      post = klass.new(title: "He who poops, shits itself")
+
+      expect(post.valid?).to be true
+      expect(post.errors).not_to have_key(:title)
+      expect(post.title).to eq("He who poops, [censored] itself")
+    end
+  end
+end

data/spec/base_spec.rb

@@ -0,0 +1,41 @@
+#base_spec.rb
+require 'spec_helper'
+require 'obscenity'
+
+RSpec.describe Obscenity::Base do
+  before do
+    Obscenity.configure do |config|
+      config.blacklist = ["badword", "foulword"]
+      config.whitelist = ["safe"]
+      config.replacement = :stars
+    end
+  end
+
+  describe "responding to methods" do
+    it "responds to expected methods" do
+      [:blacklist, :whitelist, :profane?, :sanitize, :replacement, :offensive, :replace].each do |method|
+        expect(Obscenity::Base).to respond_to(method)
+      end
+    end
+  end
+
+  describe "#profane?" do
+    it "detects profane words" do
+      expect(Obscenity::Base.profane?("badword")).to be true
+    end
+
+    it "does not detect clean words as profane" do
+      expect(Obscenity::Base.profane?("cleanword")).to be false
+    end
+  end
+
+  describe "#sanitize" do
+    it "replaces profane words with stars" do
+      expect(Obscenity::Base.sanitize("badword")).to eq("*******")
+    end
+
+    it "returns clean words unchanged" do
+      expect(Obscenity::Base.sanitize("cleanword")).to eq("cleanword")
+    end
+  end
+end

data/spec/config_spec.rb

@@ -0,0 +1,72 @@
+#config_spec.rb
+require 'spec_helper'
+require 'obscenity/config'
+
+RSpec.describe Obscenity::Config do
+  describe '#respond_to?' do
+    it 'responds to expected methods and attributes' do
+      config = Obscenity::Config.new
+      [:blacklist, :whitelist, :replacement].each do |field|
+        expect(config).to respond_to(field)
+      end
+    end
+  end
+
+  describe 'configuration parameters' do
+    it 'properly sets config parameters' do
+      blacklist = ['ass', 'shit', 'penis']
+      whitelist = ['penis']
+      replacement = :stars
+
+      config = Obscenity::Config.new do |c|
+        c.blacklist = blacklist
+        c.whitelist = whitelist
+        c.replacement = replacement
+      end
+
+      expect(config.blacklist).to eq(blacklist)
+      expect(config.whitelist).to eq(whitelist)
+      expect(config.replacement).to eq(replacement)
+    end
+
+    it 'returns default values if none are set' do
+      config = Obscenity::Config.new
+      expect(config.whitelist).to eq([])
+      expect(config.replacement).to eq(:garbled)
+      expect(config.blacklist.to_s).to match(/config\/blacklist.yml/)
+    end
+
+    it 'returns default values when explicitly set to default' do
+      config = Obscenity::Config.new do |c|
+        c.blacklist = :default
+        c.replacement = :default
+      end
+
+      expect(config.whitelist).to eq([])
+      expect(config.replacement).to eq(:default)
+      expect(config.blacklist.to_s).to match(/config\/blacklist.yml/)
+    end
+  end
+
+  describe 'validating configuration options' do
+    it 'raises exceptions for invalid config options' do
+      invalid_values = [
+        [Obscenity::UnkownContent, {}],
+        [Obscenity::UnkownContent, ":unkown"],
+        [Obscenity::EmptyContentList, []],
+        [Obscenity::UnkownContentFile, "'path/to/file'"],
+        [Obscenity::UnkownContentFile, Pathname.new("'path/to/file'")]
+      ]
+
+      [:blacklist, :whitelist].each do |field|
+        invalid_values.each do |klass, value|
+          expect {
+            Obscenity::Config.new do |config|
+              config.instance_eval("config.#{field} = #{value}")
+            end
+          }.to raise_error(klass)
+        end
+      end
+    end
+  end
+end

data/spec/factories/factory_bot.rb

@@ -0,0 +1,7 @@
+#spec/factorires/factory_bot.rb
+FactoryBot.define do
+    factory :base_model, class: Dummy::BaseModel do
+      title { "Sample title" }
+    end
+  end
+  

data/spec/obscenity_spec.rb

@@ -0,0 +1,70 @@
+#obscenity_spec.rb
+require 'spec_helper'
+require 'obscenity'
+
+RSpec.describe Obscenity do
+  before do
+    Obscenity.configure do |config|
+      config.blacklist = :default
+      config.replacement = :garbled
+    end
+  end
+
+  describe "respond_to?" do
+    it "responds to the expected methods and attributes" do
+      [:configure, :config, :profane?, :sanitize, :offensive, :replacement].each do |field|
+        expect(Obscenity).to respond_to(field)
+      end
+    end
+  end
+
+  describe ".configure" do
+    it "accepts a configuration block without raising errors" do
+      expect {
+        Obscenity.configure do |config|
+          config.blacklist = :default
+          config.replacement = :garbled
+        end
+      }.not_to raise_error
+    end
+  end
+
+  describe ".config" do
+    it "returns the current configuration object" do
+      expect(Obscenity.config).not_to be_nil
+    end
+  end
+
+  describe ".profane?" do
+    it "validates the profanity of the given content" do
+      expect(Obscenity.profane?('Yo, check that ass out')).to be true
+      expect(Obscenity.profane?('Hello world')).to be false
+    end
+  end
+
+  describe ".sanitize" do
+    it "sanitizes the given content" do
+      expect(Obscenity.sanitize('Yo, check that ass out')).to eq("Yo, check that $@!#% out")
+      expect(Obscenity.sanitize('Hello world')).to eq("Hello world")
+    end
+  end
+
+  describe ".offensive" do
+    it "returns the offensive words for the given content" do
+      expect(Obscenity.offensive('Yo, check that ass biatch')).to eq(['ass', 'biatch'])
+      expect(Obscenity.offensive('Hello world')).to eq([])
+    end
+  end
+
+  describe ".replacement" do
+    it "sanitizes the given content based on the replacement method" do
+      expect(Obscenity.replacement(:garbled).sanitize('Yo, check that ass out')).to eq("Yo, check that $@!#% out")
+      expect(Obscenity.replacement(:default).sanitize('Yo, check that ass out')).to eq("Yo, check that $@!#% out")
+      expect(Obscenity.replacement(:vowels).sanitize('Yo, check that ass out')).to eq("Yo, check that *ss out")
+      expect(Obscenity.replacement(:nonconsonants).sanitize('Yo, check that 5hit out')).to eq("Yo, check that *h*t out")
+      expect(Obscenity.replacement(:stars).sanitize('Yo, check that ass out')).to eq("Yo, check that *** out")
+      expect(Obscenity.replacement("[censored]").sanitize('Yo, check that ass out')).to eq("Yo, check that [censored] out")
+      expect(Obscenity.sanitize('Hello world')).to eq("Hello world")
+    end
+  end
+end

data/spec/rack_spec.rb

@@ -0,0 +1,99 @@
+require 'rack/mock'
+require 'obscenity/rack'
+
+RSpec.describe Rack::Obscenity do
+  let(:app) do
+    lambda { |env| [200, { 'Content-Type' => 'text/plain' }, ['hello']] }
+  end
+
+  let(:env) { Rack::MockRequest.env_for('/') }
+
+  def middleware(options = {})
+    described_class.new(app, options)
+  end
+
+  def get(params = {})
+    { 'QUERY_STRING' => Rack::Utils.build_query(params) }
+  end
+
+  def post(params = {})
+    { 'rack.input' => StringIO.new(Rack::Utils.build_query(params)) }
+  end
+
+  def parse_query(query)
+    Rack::Utils.parse_query(query, '&')
+  end
+
+  def get_response_params(env)
+    parse_query(env['QUERY_STRING'])
+  end
+
+  def post_response_params(env)
+    parse_query(env['rack.input'].read)
+  end
+
+  def call_middleware(middleware, options)
+    middleware.call(Rack::MockRequest.env_for('/', options))
+  end
+
+  it "does not evaluate profanity by default" do
+    app = middleware
+    status, headers, body = call_middleware(app, {})
+    expect(status).to eq(200)
+    expect(headers).to eq('Content-Type' => 'text/plain')
+    expect(body).to eq(['hello'])
+  end
+
+  context "rejecting requests" do
+    it "does not reject non-profane parameters" do
+      app = middleware(reject: true)
+      status, headers, body = call_middleware(app, get(foo: 'bar'))
+      expect(status).to eq(200)
+      expect(headers).to eq('Content-Type' => 'text/plain')
+      expect(body).to eq(['hello'])
+    end
+
+    it "rejects requests with GET parameters containing profanity" do
+      app = middleware(reject: true)
+      status, headers, body = call_middleware(app, get(foo: 'bar', baz: 'shit'))
+      expect(status).to eq(422)
+      expect(body).to eq([''])
+    end
+
+    it "rejects requests with POST parameters containing profanity" do
+      app = middleware(reject: true)
+      status, headers, body = call_middleware(app, post(foo: 'bar', baz: 'ass'))
+      expect(status).to eq(422)
+      expect(body).to eq([''])
+    end
+
+    it "rejects requests with specific parameter values containing profanity" do
+      app = middleware(reject: { params: [:foo] })
+      status, headers, body = call_middleware(app, get(foo: 'ass', baz: 'clean'))
+      expect(status).to eq(422)
+      expect(body).to eq([''])
+    end
+
+    it "does not reject requests if other parameter values contain profanity" do
+      app = middleware(reject: { params: [:foo] })
+      status, headers, body = call_middleware(app, get(foo: 'clean', baz: 'shit'))
+      expect(status).to eq(200)
+      expect(headers).to eq('Content-Type' => 'text/plain')
+      expect(body).to eq(['hello'])
+    end
+  end
+
+  context "sanitizing requests" do
+    it "does not sanitize non-profane parameters" do
+      app = middleware(sanitize: true)
+      status, headers, body = call_middleware(app, get(foo: 'bar'))
+      expect(status).to eq(200)
+      expect(headers).to eq('Content-Type' => 'text/plain')
+      expect(body).to eq(['hello'])
+
+      request_params = get_response_params(env)
+      expect(request_params['foo']).to eq('bar')
+    end
+
+    it "sanitizes GET parameters containing profanity" do
+      app = middleware(sanitize: tru

data/spec/spec_helper.rb

@@ -0,0 +1,36 @@
+require 'rubygems'
+require 'bundler/setup'
+require 'rspec'
+require 'factory_bot'
+
+# Load ActiveModel and Obscenity
+require 'active_model'
+require 'obscenity'
+require 'obscenity/active_model'
+
+# Load the Dummy module and BaseModel class
+require_relative 'support/dummy_base_model'
+
+# Dummy Model for Testing
+FactoryBot.define do
+  factory :base_model, class: Dummy::BaseModel do
+    title { "Sample title" }
+  end
+end
+
+# Configure RSpec
+RSpec.configure do |config|
+  Obscenity.configure do |c|
+    puts "DEBUG: Configuring blacklist in tests"
+    c.blacklist = ["badword"]
+    c.whitelist = []
+    c.replacement = :stars
+  end
+end
+
+# Load support files and factory definitions
+Dir[File.join(__dir__, 'support/**/*.rb')].each { |file| require file }
+FactoryBot.definition_file_paths = [File.expand_path('spec/factories', __dir__)]
+FactoryBot.find_definitions
+
+Obscenity::Config::DEFAULT_BLACKLIST = ["badword"]

data/spec/support/dummy_base_model.rb

@@ -0,0 +1,8 @@
+#spec/support/dummy_base_model.rb
+module Dummy
+    class BaseModel
+      include ActiveModel::Model
+      attr_accessor :title
+    end
+  end
+  

data/spec/validators/obscenity_validator_spec.rb

@@ -0,0 +1,53 @@
+#spec/validators/obscenity_validator_spec.rb
+# test to ensure that the ObscenityValidator is working as expected
+require 'spec_helper'
+
+puts "Blacklist: #{Obscenity.config.blacklist}"
+
+RSpec.describe ActiveModel::Validations::ObscenityValidator do
+    before do
+        Obscenity.configure do |config|
+            config.blacklist = ["badword"]
+            config.whitelist = []
+            config.replacement = :stars
+        end
+    end
+
+    let(:dummy_class) do
+        Class.new do
+            include ActiveModel::Validations
+            attr_accessor :title, :content
+            validates :title, obscenity: { message: "cannot be profane" }
+            validates :content, obscenity: { sanitize: true, replacement: '[censored]' }
+        end
+    end
+
+    let(:dummy_instance) { dummy_class.new }
+
+    context "when validating profanity" do
+        it "adds an error message when profane" do
+            dummy_instance.title = "This is a badword"
+            expect(dummy_instance.valid?).to be false
+            expect(dummy_instance.errors[:title]).to include("cannot be profane")
+        end
+
+        it "does not add an error for clean words" do
+            dummy_instance.title = "This is clean"
+            expect(dummy_instance.valid?).to be true
+          end
+        end
+      
+        context "when sanitizing profanity" do
+          it "sanitizes profane words" do
+            dummy_instance.content = "This is a badword"
+            dummy_instance.valid? # Trigger the validation
+            expect(dummy_instance.content).to eq("This is a [censored]")
+          end
+      
+          it "leaves clean words unchanged" do
+            dummy_instance.content = "This is clean"
+            expect(dummy_instance.valid?).to be true
+            expect(dummy_instance.content).to eq("This is clean")
+          end
+        end
+      end

data/spec/version_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+RSpec.describe Obscenity do
+  it "returns the correct product version" do
+    expect(Obscenity::VERSION).to eq('1.0.2')
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: obscenity-plus
 version: !ruby/object:Gem::Version
-  version: 1.0.6
+  version: 1.0.7
 platform: ruby
 authors:
 - Ropetow
@@ -113,6 +113,16 @@ files:
 - lib/obscenity/rack.rb
 - lib/obscenity/rspec_matcher.rb
 - lib/obscenity/version.rb
+- spec/active_model_spec.rb
+- spec/base_spec.rb
+- spec/config_spec.rb
+- spec/factories/factory_bot.rb
+- spec/obscenity_spec.rb
+- spec/rack_spec.rb
+- spec/spec_helper.rb
+- spec/support/dummy_base_model.rb
+- spec/validators/obscenity_validator_spec.rb
+- spec/version_spec.rb
 homepage: http://github.com/ropetow/obscenity-plus
 licenses:
 - MIT