obscenity2 0.0.1

data/test/test_config.rb

@@ -0,0 +1,66 @@
+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

@@ -0,0 +1,69 @@
+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

@@ -0,0 +1,207 @@
+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_version.rb

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

metadata

@@ -0,0 +1,79 @@
+--- !ruby/object:Gem::Specification
+name: obscenity2
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Thiago Jackiw
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-03-04 00:00:00.000000000 Z
+dependencies: []
+description: " Obscenity is a profanity filter gem for Ruby/Rubinius, Rails (through
+  ActiveModel), and Rack middleware "
+email: tjackiw@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".document"
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- config/blacklist.yml
+- config/international.yml
+- lib/obscenity.rb
+- lib/obscenity/active_model.rb
+- lib/obscenity/base.rb
+- lib/obscenity/config.rb
+- lib/obscenity/error.rb
+- lib/obscenity/rack.rb
+- lib/obscenity/rspec_matcher.rb
+- lib/obscenity/version.rb
+- obscenity.gemspec
+- 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_version.rb
+homepage: http://github.com/tjackiw/obscenity
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: Obscenity is a profanity filter gem for Ruby/Rubinius, Rails (through ActiveModel),
+  and Rack middleware
+test_files:
+- 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_version.rb