obscenity-plus 1.0.3 → 1.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 87ea13418f423c2e3e4df58cee095bfe87d68df3a2ea584860df1fafd02da412
-  data.tar.gz: 6111431fb83fe7e754d025e61025d6a1ffd66ea380a689b14bd37cd010b5763a
+  metadata.gz: 95fe7b37b3b580613fcce66b26012a7b5f3499bca65e62806297d55034fa4d35
+  data.tar.gz: 898a7965d4fa9fcd0e650ecce0d2af58ccc40e4c28a796a2ffa20366fbde78f1
 SHA512:
-  metadata.gz: c4229f4e7a99b6af5c3d5ea422714ea0fbc0baa98089e430011b9633373a47b35ae1f5bca5b4593008cf73c5c92eda8dc5098f8dff76b4e1564b947c51133b24
-  data.tar.gz: ade9c9f58e419ac58edfe891a8032827f8396eef86ab3043625f3b9549341ddaf6236342d61f67edc2ef314dedb66bb217469291ee332f8e8ad1b43227b3ecc4
+  metadata.gz: 7ff216439ef22b2a0881b70d16181d99208b258d515f3266e086a333ac6db403dca34cc559fa62487716d7028f7666e5acac40a5913deccf0a3590e05d69a1d1
+  data.tar.gz: '091bfbae422af0095219191ab00f00ebdb006debf095ce4c1b1004968da50f7d149ac03d03c71ade1d1178378ccf47c11900abf1bd8a520eed51237daad44d54'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: obscenity-plus
 version: !ruby/object:Gem::Version
-  version: 1.0.3
+  version: 1.0.4
 platform: ruby
 authors:
 - Ropetow
@@ -113,15 +113,6 @@ files:
 - lib/obscenity/rack.rb
 - lib/obscenity/rspec_matcher.rb
 - lib/obscenity/version.rb
-- test/helper.rb
-- test/static/422.html
-- test/test_active_model.rb
-- test/test_base.rb
-- test/test_config.rb
-- test/test_obscenity.rb
-- test/test_rack.rb
-- test/test_test.rb
-- test/test_version.rb
 homepage: http://github.com/ropetow/obscenity-plus
 licenses:
 - MIT
@@ -134,7 +125,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2.7'
+      version: '3.0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="

data/test/helper.rb

@@ -1,29 +0,0 @@
-#helper.rb
-require 'rubygems'
-require 'bundler/setup'
-require 'rspec'
-
-# Load ActiveModel and Obscenity
-require 'active_model'
-require 'obscenity'
-require 'obscenity/active_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|
-  config.expect_with :rspec do |expectations|
-    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
-  end
-
-  config.mock_with :rspec do |mocks|
-    mocks.verify_partial_doubles = true
-  end
-
-  config.shared_context_metadata_behavior = :apply_to_host_groups
-end

data/test/static/422.html

@@ -1 +0,0 @@
-We don't accept profanity

data/test/test_active_model.rb

@@ -1,70 +0,0 @@
-#test_active_model.rb
-require 'helper'
-
-class TestActiveModel < Test::Unit::TestCase
-  
-  def generate_new_class(name, options = {})
-    Dummy.send(:remove_const, name) if Dummy.const_defined?(name)
-    klass = Class.new(Dummy::BaseModel) do
-      validates :title, options
-    end
-    Dummy.const_set(name, klass)
-  end
-
-  should "be invalid when title is profane" do
-    klass = generate_new_class("Post", obscenity: true)
-    post  = klass.new(title: "He who poops, shits itself")
-    assert !post.valid?
-    assert post.errors.has_key?(:title)
-    assert_equal ['cannot be profane'], post.errors[:title]
-  end
-
-  should "be invalid when title is profane and should include a custom error message" do
-    klass = generate_new_class("Post", obscenity: { message: "can't be profane!" })
-    post  = klass.new(title: "He who poops, shits itself")
-    assert !post.valid?
-    assert post.errors.has_key?(:title)
-    assert_equal ["can't be profane!"], post.errors[:title]
-  end
-
-  should "sanitize the title using the default replacement" do
-    klass = generate_new_class("Post", obscenity: { sanitize: true })
-    post  = klass.new(title: "He who poops, shits itself")
-    assert post.valid?
-    assert !post.errors.has_key?(:title)
-    assert_equal "He who poops, $@!#% itself", post.title
-  end
-  
-  should "sanitize the title using the :garbled replacement" do
-    klass = generate_new_class("Post", obscenity: { sanitize: true, replacement: :garbled })
-    post  = klass.new(title: "He who poops, shits itself")
-    assert post.valid?
-    assert !post.errors.has_key?(:title)
-    assert_equal "He who poops, $@!#% itself", post.title
-  end
-
-  should "sanitize the title using the :stars replacement" do
-    klass = generate_new_class("Post", obscenity: { sanitize: true, replacement: :stars })
-    post  = klass.new(title: "He who poops, shits itself")
-    assert post.valid?
-    assert !post.errors.has_key?(:title)
-    assert_equal "He who poops, ***** itself", post.title
-  end
-
-  should "sanitize the title using the :vowels replacement" do
-    klass = generate_new_class("Post", obscenity: { sanitize: true, replacement: :vowels })
-    post  = klass.new(title: "He who poops, shits itself")
-    assert post.valid?
-    assert !post.errors.has_key?(:title)
-    assert_equal "He who poops, sh*ts itself", post.title
-  end
-
-  should "sanitize the title using a custom replacement" do
-    klass = generate_new_class("Post", obscenity: { sanitize: true, replacement: '[censored]' })
-    post  = klass.new(title: "He who poops, shits itself")
-    assert post.valid?
-    assert !post.errors.has_key?(:title)
-    assert_equal "He who poops, [censored] itself", post.title
-  end
-
-end

data/test/test_base.rb

@@ -1,29 +0,0 @@
-# test_base.rb
-require 'test/unit'
-require 'obscenity'
-
-class TestObscenityBase < Test::Unit::TestCase
-  def setup
-    Obscenity.configure do |config|
-      config.blacklist = ["badword"]
-      config.whitelist = []
-      config.replacement = :stars
-    end
-  end
-
-  def test_methods_respond
-    [:blacklist, :whitelist, :profane?, :sanitize, :replacement, :offensive, :replace].each do |method|
-      assert_respond_to Obscenity::Base, method
-    end
-  end
-
-  def test_profane_detection
-    assert Obscenity::Base.profane?("badword")
-    assert !Obscenity::Base.profane?("cleanword")
-  end
-
-  def test_sanitization
-    assert_equal "*******", Obscenity::Base.sanitize("badword")
-    assert_equal "cleanword", Obscenity::Base.sanitize("cleanword")
-  end
-end

data/test/test_config.rb

@@ -1,67 +0,0 @@
-#test_config.rb
-require 'helper'
-
-class TestConfig < Test::Unit::TestCase
-
-  context "#respond_to?" do
-    should "respond to methods and attributes" do
-      Obscenity::Config.new do |config|
-        [:blacklist, :whitelist, :replacement].each do |field|
-          assert config.respond_to?(field)
-        end
-      end
-    end
-  end
-  
-  should "properly set the config parameters" do
-    blacklist   = ['ass', 'shit', 'penis']
-    whitelist   = ['penis']
-    replacement = :stars
-    
-    config = Obscenity::Config.new do |config|
-      config.blacklist   = blacklist
-      config.whitelist   = whitelist
-      config.replacement = replacement
-    end
-    
-    assert_equal blacklist, config.blacklist
-    assert_equal whitelist, config.whitelist
-    assert_equal replacement, config.replacement
-  end
-
-  should "return default values if none is set" do
-    config = Obscenity::Config.new
-    assert_equal [], config.whitelist
-    assert_equal :garbled, config.replacement
-    assert_match /config\/blacklist.yml/, config.blacklist
-  end
-
-  should "return default values when default values are set" do
-    config = Obscenity::Config.new do |config|
-      config.blacklist   = :default
-      config.replacement = :default
-    end
-    assert_equal [], config.whitelist
-    assert_equal :default, config.replacement
-    assert_match /config\/blacklist.yml/, config.blacklist
-  end
-  
-  should "properly validate the config options" do
-    [:blacklist, :whitelist].each do |field|
-      exceptions = [
-        [Obscenity::UnkownContent, {}], 
-        [Obscenity::UnkownContent, ":unkown"], 
-        [Obscenity::EmptyContentList, []], 
-        [Obscenity::UnkownContentFile, "'path/to/file'"], 
-        [Obscenity::UnkownContentFile, Pathname.new("'path/to/file'")]
-      ].each do |klass, value|
-        assert_raise(klass){
-          Obscenity::Config.new do |config|
-            config.instance_eval "config.#{field} = #{value}"
-          end
-        }
-      end
-    end
-  end
-  
-end

data/test/test_obscenity.rb

@@ -1,70 +0,0 @@
-#test_obscenity.rb
-require 'helper'
-
-class TestObscenity < Test::Unit::TestCase
-
-  context "#respond_to?" do
-    should "respond to methods and attributes" do
-      [:configure, :config, :profane?, :sanitize, :offensive, :replacement].each do |field|
-        assert Obscenity.respond_to?(field)
-      end
-    end
-  end
-
-  # More comprehensive test in test_config.rb
-  context "#configure" do
-    should "accept a configuration block " do
-      assert_nothing_raised{
-        Obscenity.configure do |config|
-          config.blacklist   = :default
-          config.replacement = :garbled
-        end
-      }
-    end
-  end
-
-  # More comprehensive test in test_config.rb
-  context "#config" do
-    should "return the current config object" do
-      assert_not_nil Obscenity.config
-    end
-  end
-
-  # More comprehensive test in test_base.rb
-  context "#profane?" do
-    should "validate the profanity of the given content" do
-      assert Obscenity.profane?('Yo, check that ass out')
-      assert !Obscenity.profane?('Hello world')
-    end
-  end
-
-  # More comprehensive test in test_base.rb
-  context "#sanitize" do
-    should "sanitize the given content" do
-      assert_equal "Yo, check that $@!#% out", Obscenity.sanitize('Yo, check that ass out')
-      assert_equal "Hello world", Obscenity.sanitize('Hello world')
-    end
-  end
-
-  # More comprehensive test in test_base.rb
-  context "#offensive" do
-    should "return the offensive words for the given content" do
-      assert_equal ['ass', 'biatch'], Obscenity.offensive('Yo, check that ass biatch')
-      assert_equal [], Obscenity.offensive('Hello world')
-    end
-  end
-
-  # More comprehensive test in test_base.rb
-  context "#replacement" do
-    should "sanitize the given content based on the given replacement" do
-      assert_equal "Yo, check that $@!#% out", Obscenity.replacement(:garbled).sanitize('Yo, check that ass out')
-      assert_equal "Yo, check that $@!#% out", Obscenity.replacement(:default).sanitize('Yo, check that ass out')
-      assert_equal "Yo, check that *ss out", Obscenity.replacement(:vowels).sanitize('Yo, check that ass out')
-      assert_equal "Yo, check that *h*t out", Obscenity.replacement(:nonconsonants).sanitize('Yo, check that 5hit out')
-      assert_equal "Yo, check that *** out", Obscenity.replacement(:stars).sanitize('Yo, check that ass out')
-      assert_equal "Yo, check that [censored] out", Obscenity.replacement("[censored]").sanitize('Yo, check that ass out')
-      assert_equal "Hello world", Obscenity.sanitize('Hello world')
-    end
-  end
-
-end

data/test/test_rack.rb

@@ -1,207 +0,0 @@
-require 'helper'
-require 'rack/mock'
-require 'obscenity/rack'
-
-class TestRack < Test::Unit::TestCase
-
-  context "Rack::Obscenity" do
-    setup do
-      @env     = {}
-      @body    = 'hello'
-      @status  = 200
-      @headers = { 'Content-Type' => 'text/plain' }
-      @app     = lambda { |env| [@status, @headers, [@body]] }
-    end
-
-    def mock_env(options = {})
-      @env = Rack::MockRequest.env_for('/', options)
-    end
-
-    def middleware(options = {})
-      Rack::Obscenity.new(@app, options)
-    end
-
-    def get(params = {})
-      { 'QUERY_STRING' => Rack::Utils.build_query(params) }
-    end
-
-    def get_response_params
-      Rack::Utils.parse_query(@env['QUERY_STRING'], "&")
-    end
-
-    def post(params = {})
-      { 'rack.input' => StringIO.new(Rack::Utils.build_query(params)) }
-    end
-
-    def post_response_params
-      Rack::Utils.parse_query(@env['rack.input'].read, "&")
-    end
-
-    def assert_success_response(status, headers, body)
-      assert_equal @status, status
-      assert_equal @headers, headers
-      assert_equal [@body], body
-    end
-
-    context "default configuration" do
-      should "not evaluate the profanity of parameters" do
-        app = middleware
-        status, headers, body = app.call(mock_env)
-        assert_success_response status, headers, body
-      end
-    end
-
-    context "rejecting requests" do
-      should "not reject if parameter values don't contain profanity" do
-        app = middleware(reject: true)
-        status, headers, body = app.call(mock_env(get(foo: 'bar')))
-        assert_success_response status, headers, body
-      end
-
-      should "reject if GET parameter values contain profanity" do
-        app = middleware(reject: true)
-        status, headers, body = app.call(mock_env(get(foo: 'bar', baz: 'shit')))
-        assert_equal 422, status
-        assert_equal [''], body
-      end
-
-      should "reject if POST parameter values contain profanity" do
-        app = middleware(reject: true)
-        status, headers, body = app.call(mock_env(post(foo: 'bar', baz: 'ass')))
-        assert_equal 422, status
-        assert_equal [''], body
-      end
-
-      should "reject if given parameter values contain profanity" do
-        app = middleware(reject: { params: [:foo] })
-        [ get(foo: 'ass', baz: 'shit'),
-          post(foo: 'ass').merge(get(foo: 'nice', baz: 'shit'))
-        ].each do |options|
-          status, headers, body = app.call(mock_env(options))
-          assert_equal 422, status
-          assert_equal [''], body
-        end
-      end
-
-      should "not reject if other parameter values contain profanity" do
-        app = middleware(reject: { params: [:foo] })
-        status, headers, body = app.call(mock_env(get(foo: 'nice', baz: 'shit')))
-        assert_success_response status, headers, body
-      end
-
-      should "reject if parameter values contain profanity" do
-        app = middleware(reject: { params: :all })
-        status, headers, body = app.call(mock_env(get(foo: 'ass')))
-        assert_equal 422, status
-        assert_equal [''], body
-      end
-
-      should "reject if parameter values contain profanity and display a custom message" do
-        app = middleware(reject: { message: "We don't accept profanity" })
-        status, headers, body = app.call(mock_env(get(foo: 'ass')))
-        assert_equal 422, status
-        assert_equal ["We don't accept profanity"], body
-      end
-
-      should "reject if parameter values contain profanity and render a custom file" do
-        app = middleware(reject: { path: "test/static/422.html" })
-        status, headers, body = app.call(mock_env(get(foo: 'ass')))
-        assert_equal 422, status
-        assert_equal ["We don't accept profanity"], body
-      end
-
-      should "reject parameter values when they're a hash and contain profanity" do
-        app = middleware(reject: true)
-        status, headers, body = app.call(mock_env(get(foo: 'clean', bar: {one: 'ass'})))
-        assert_equal 422, status
-        assert_equal [''], body
-      end
-    end
-
-    context "sanitizing requests" do
-      should "not sanitize if parameter values don't contain profanity" do
-        app = middleware(sanitize: true)
-        status, headers, body = app.call(mock_env(get(foo: 'bar')))
-        assert_success_response status, headers, body
-        request_params = get_response_params
-        assert_equal 'bar', request_params['foo']
-      end
-
-      should "sanitize if GET parameter values contain profanity" do
-        app = middleware(sanitize: true)
-        status, headers, body = app.call(mock_env(get(foo: 'bar', baz: 'shit')))
-        assert_success_response status, headers, body
-        request_params = get_response_params
-        assert_equal 'bar', request_params['foo']
-        assert_equal '$@!#%', request_params['baz']
-      end
-
-      should "sanitize if POST parameter values contain profanity" do
-        app = middleware(sanitize: true)
-        status, headers, body = app.call(mock_env(post(foo: 'bar', baz: 'ass')))
-        assert_success_response status, headers, body
-        request_params = post_response_params
-        assert_equal 'bar', request_params['foo']
-        assert_equal '$@!#%', request_params['baz']
-      end
-
-      should "not sanitize if other parameter values contain profanity" do
-        app = middleware(sanitize: { params: [:foo] })
-        status, headers, body = app.call(mock_env(get(foo: 'nice', baz: 'shit')))
-        assert_success_response status, headers, body
-        request_params = get_response_params
-        assert_equal 'nice', request_params['foo']
-        assert_equal 'shit', request_params['baz']
-      end
-
-      should "sanitize if parameter values contain profanity" do
-        app = middleware(sanitize: { params: :all })
-        status, headers, body = app.call(mock_env(get(foo: 'ass')))
-        assert_success_response status, headers, body
-        request_params = get_response_params
-        assert_equal '$@!#%', request_params['foo']
-      end
-
-      should "sanitize the title using the :garbled replacement" do
-        app = middleware(sanitize: { replacement: :garbled })
-        status, headers, body = app.call(mock_env(get(foo: 'ass')))
-        assert_success_response status, headers, body
-        request_params = get_response_params
-        assert_equal '$@!#%', request_params['foo']
-      end
-
-      should "sanitize the title using the :stars replacement" do
-        app = middleware(sanitize: { replacement: :stars })
-        status, headers, body = app.call(mock_env(get(foo: 'ass')))
-        assert_success_response status, headers, body
-        request_params = get_response_params
-        assert_equal '***', request_params['foo']
-      end
-
-      should "sanitize the title using the :vowels replacement" do
-        app = middleware(sanitize: { replacement: :vowels })
-        status, headers, body = app.call(mock_env(get(foo: 'ass')))
-        assert_success_response status, headers, body
-        request_params = get_response_params
-        assert_equal '*ss', request_params['foo']
-      end
-
-      should "sanitize the title using the :nonconsonants replacement" do
-        app = middleware(sanitize: { replacement: :nonconsonants })
-        status, headers, body = app.call(mock_env(get(foo: '5hit')))
-        assert_success_response status, headers, body
-        request_params = get_response_params
-        assert_equal '*h*t', request_params['foo']
-      end
-
-      should "sanitize the title using a custom replacement" do
-        app = middleware(sanitize: { replacement: "[censored]" })
-        status, headers, body = app.call(mock_env(get(foo: 'text with ass')))
-        assert_success_response status, headers, body
-        request_params = get_response_params
-        assert_equal 'text with [censored]', request_params['foo']
-      end
-    end
-  end
-
-end

data/test/test_test.rb

@@ -1,17 +0,0 @@
-#first test of the gem and rspec
-require 'rails_helper'
-
-RSpec.describe Dummy::BaseModel, type: :model do
-  before do
-    Obscenity.configure do |config|
-      config.blacklist   = ["badword"]
-      config.replacement = :stars
-    end
-  end
-
-  it "validates profanity in the title" do
-    model = Dummy::BaseModel.new(title: "This is a badword")
-    expect(Obscenity.profane?(model.title)).to be true
-    expect(Obscenity.sanitize(model.title)).to eq "This is a *******"
-  end
-end

data/test/test_version.rb

@@ -1,9 +0,0 @@
-require 'helper'
-
-class TestVersion < Test::Unit::TestCase
-
-  should "return the correct product version" do
-    assert_equal '1.0.2', Obscenity::VERSION
-  end
-
-end