filter8 0.9

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 720eb0a7f14ad24804b6fa997fd683814a5c0560
+  data.tar.gz: ab82cedaa9c4fdf715eb401ff312e6091f65861f
+SHA512:
+  metadata.gz: febb61d5262767ce53f9c650d66856f7f95a5e01261a7a680a563f7425e9708b45c6723335193fb358a67c3464ef1c542591d38227b0938fc13bfe07bc7e57fd
+  data.tar.gz: ac2ac322dd474d1d943ea1f8a0f95a74615a18688d1302f15b01f0a976caeb6a0244013242f2a8836950350a6b5e1e105b098d1357245e82f57d9a64102800ef

data/.gitignore

@@ -0,0 +1,3 @@
+bin
+coverage
+*.gem

data/.rspec

@@ -0,0 +1 @@
+--color

data/Gemfile

@@ -0,0 +1,2 @@
+source "https://rubygems.org"
+gemspec

data/Gemfile.lock

@@ -0,0 +1,42 @@
+PATH
+  remote: .
+  specs:
+    filter8 (0.1)
+      faraday
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    codeclimate-test-reporter (0.3.0)
+      simplecov (>= 0.7.1, < 1.0.0)
+    diff-lcs (1.2.5)
+    docile (1.1.3)
+    faraday (0.9.0)
+      multipart-post (>= 1.2, < 3)
+    multi_json (1.10.1)
+    multipart-post (2.0.0)
+    rake (10.1.1)
+    rspec (2.14.1)
+      rspec-core (~> 2.14.0)
+      rspec-expectations (~> 2.14.0)
+      rspec-mocks (~> 2.14.0)
+    rspec-core (2.14.8)
+    rspec-expectations (2.14.5)
+      diff-lcs (>= 1.1.3, < 2.0)
+    rspec-mocks (2.14.6)
+    simplecov (0.8.2)
+      docile (~> 1.1.0)
+      multi_json
+      simplecov-html (~> 0.8.0)
+    simplecov-html (0.8.0)
+    timecop (0.6.3)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  codeclimate-test-reporter
+  filter8!
+  rake (~> 10.1.0)
+  rspec (~> 2.14.1)
+  timecop

data/README.md

@@ -0,0 +1,47 @@
+# filter8
+A unofficial ruby wrapper for Filter8 (http://filter8.com). An API to filter lots of stuff from texts, e.g. bad words. 
+
+[![Code Climate](https://codeclimate.com/github/toadle/filter8/badges/gpa.svg)](https://codeclimate.com/github/toadle/filter8)
+[![Test Coverage](https://codeclimate.com/github/toadle/filter8/badges/coverage.svg)](https://codeclimate.com/github/toadle/filter8)
+
+# Installation
+
+
+As you'd expect. Nothing special here: 
+
+```
+gem install filter8
+```
+
+# How to use
+
+## Configuration
+
+Before you use Filter8 you need to configure it:
+```
+Filter8.configure do |config|
+  config.api_key = "your filter8-api-key"
+  config.api_secret = "your filter8-api-secret"
+end
+```
+
+## Usage
+
+Simply send the content, you wish to filter with the filter-method: 
+```
+Filter8.filter("your content")
+```
+
+If you want to change the **default-options** of filter8 (https://filter8.com/documentation), you can pass an optional options-hash with the filter-configuration:
+```
+Filter8.filter("your content", blacklist: {enabled: true, locales: [:en, :de, :fr], tags: ["AsciiArt"]})
+```
+
+The **email** and **urls** filters are not yet supported.
+
+## Feedback
+Feedback and pull-request are always welcome. 
+You can find the author via http://toadle.me
+
+## License
+The filter8-gem is released under the [MIT License](http://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,7 @@
+require "bundler"
+require 'rspec/core/rake_task'
+
+task :default => :spec
+
+Bundler::GemHelper.install_tasks
+RSpec::Core::RakeTask.new :spec

data/filter8.gemspec

@@ -0,0 +1,27 @@
+Gem::Specification.new do |s|
+  s.name                      = "filter8"
+  s.version                   = "0.9"
+  s.default_executable        = "hola"
+
+  s.authors                   = ["Tim Adler"]
+  s.date                      = %q{2014-08-19}
+  s.description               = %q{An unofficial ruby wrapper for Filter8 (http://filter8.com). An API to filter lots of stuff from texts, e.g. bad words.}
+  s.summary                   = %q{An unofficial ruby wrapper for Filter8 (http://filter8.com). An API to filter lots of stuff from texts, e.g. bad words.}
+  s.email                     = %q{mail (at) toadle (dot) me}
+  s.license = "MIT"
+
+  s.files                     = `git ls-files`.split("\n")
+  s.test_files                = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.homepage                  = %q{https://github.com/toadle/filter8}
+  s.require_paths             = ["lib"]
+  s.rubygems_version          = %q{1.6.2}
+
+  s.add_dependency 'faraday'
+
+  s.add_development_dependency 'rake', '~> 10.1.0'
+  s.add_development_dependency 'rspec', '~> 2.14.1'
+  s.add_development_dependency 'timecop'
+  s.add_development_dependency 'codeclimate-test-reporter'
+
+end
+

data/lib/filter8.rb

@@ -0,0 +1,46 @@
+require "filter8/exception"
+require "filter8/client"
+require "filter8/result"
+require "filter8/request"
+
+module Filter8
+  BLACKLIST_FILTER = :blacklist
+  CHARACTERS_FILTER = :characters
+  EMAILS = :emails
+  PHONE_NUMBERS_FILTER = :phoneNumbers
+  URLS_FILTER = :urls
+  WORDS_FILTER = :words
+
+  AVAILABLE_FILTERS = [BLACKLIST_FILTER, CHARACTERS_FILTER, EMAILS, PHONE_NUMBERS_FILTER, URLS_FILTER, WORDS_FILTER]
+
+  FILTER_PARAMS = {
+    BLACKLIST_FILTER => [:enabled, :locale, :tags, :severity], 
+    CHARACTERS_FILTER => [:character],
+    PHONE_NUMBERS_FILTER => [:maximumMatchLength, :minimumMatchLength, :separatorPenalty, :spacePenalty, :wordPenalty],
+    WORDS_FILTER => [:word]
+  }
+  
+  class Configuration
+    attr_accessor :api_key
+    attr_accessor :api_secret
+  end
+
+  class << self
+    attr_accessor :configuration
+  end
+
+  def self.configure
+    self.configuration ||= Configuration.new
+    yield(configuration)
+  end
+
+  def self.filter(content, options = {})
+    raise Exception.new "Configure Filter8-module before using" if(Filter8.configuration.nil?)
+    %i(api_key api_secret).each do |attribute|
+      raise Exception.new "Configure 'attribute' first" if(Filter8.configuration.send(attribute).nil?)
+    end
+
+    client = Filter8::Client.new(api_key: Filter8.configuration.api_key, api_secret: Filter8.configuration.api_secret)
+    client.send_request(Filter8::Request.new(content, options))
+  end
+end

data/lib/filter8/client.rb

@@ -0,0 +1,45 @@
+require 'digest'
+require 'uri'
+require 'faraday'
+require 'json'
+
+module Filter8
+  class Client
+    attr_accessor :api_key, :api_secret
+
+    API_URL = 'https://api.filter8.com'
+    API_ENDPOINT = '/content/item.js'
+
+    def initialize(api_key: nil, api_secret: nil, options: {})
+      @api_key = api_key
+      @api_secret = api_secret
+      @options = options
+    end
+
+    def send_request(filter8_request)
+      conn = Faraday.new(:url => API_URL) do |faraday|
+        faraday.request  :url_encoded
+        faraday.adapter  Faraday.default_adapter
+      end
+
+      conn.basic_auth self.api_key, password
+      response = conn.post "#{API_ENDPOINT}?#{nonce_param}", filter8_request.request_params
+
+      raise Exception.new("Filter8-API error (Status: #{response.status}): #{response.body}") if(response.status != 200)
+
+      JSON.parse response.body
+    end
+
+    def nonce_param
+      "nonce=#{timestamp}"
+    end
+
+    def password 
+      Digest::MD5.hexdigest("#{timestamp}#{self.api_secret}")
+    end
+
+    def timestamp 
+      @timestamp ||= Time.now.to_i.to_s
+    end
+  end
+end

data/lib/filter8/exception.rb

@@ -0,0 +1,5 @@
+module Filter8
+  class Exception < StandardError
+
+  end
+end

data/lib/filter8/request.rb

@@ -0,0 +1,74 @@
+module Filter8
+  class Request
+    attr_accessor :content
+
+    def initialize(content, options = {})
+      if content.is_a? Hash
+        @content = content[:content]
+        raise Exception.new("No value for 'content' given") if @content.nil?
+        options = content.reject!{ |k| k == :content }
+      else
+        @content = content
+      end
+
+      options.each do |filter_name, filter_options|
+        validate_filter_options(filter_name, filter_options)
+
+        instance_variable_value = nil
+        if filter_options.is_a? Hash
+          instance_variable_value = { enabled: true }
+          instance_variable_value = instance_variable_value.merge(filter_options)
+        else
+          instance_variable_value = filter_options
+        end
+        instance_variable_set("@#{filter_name}", instance_variable_value)
+        self.class.send(:attr_accessor, filter_name)
+      end
+    end
+
+    def request_params
+      request_params = "content=#{self.content}"
+
+      Filter8::AVAILABLE_FILTERS.each do |filter_name|
+        if self.respond_to?(filter_name) && !self.send(filter_name).nil?
+          request_params = request_params + "&" + filter_options_to_params(filter_name)          
+        end
+      end
+
+      request_params
+    end
+
+    private
+
+      def filter_options_to_params(filter_name)
+        params = []
+
+        filter_options = self.send(filter_name)
+        if filter_options.is_a? Hash
+          filter_options.each do |filter_option, filter_option_value|
+            if filter_option_value.respond_to? :each
+              filter_option_value.each do |value|
+                params << "#{filter_name}.#{filter_option}=#{value}"
+              end
+            else
+              params << "#{filter_name}.#{filter_option}=#{filter_option_value}"
+            end
+          end
+        else
+          params << "#{filter_name}=#{filter_options}"
+        end
+
+        return params.join("&")
+      end
+
+      def validate_filter_options(filter_name, filter_options)
+        raise Exception.new("'#{filter_name}' is not a valid filter8-filter") unless Filter8::AVAILABLE_FILTERS.include?(filter_name)
+
+        if filter_options.respond_to? :each
+          filter_options.each do |filter_option, filter_option_value|
+            raise Exception.new("'#{filter_option}' is not a valid option for filter '#{filter_name}'") unless Filter8::FILTER_PARAMS[filter_name].include?(filter_option)
+          end
+        end
+      end
+  end
+end

data/lib/filter8/result.rb

@@ -0,0 +1,22 @@
+module Filter8
+  class Result
+    attr_accessor :json
+
+    def initialize(json)
+      @json = json
+    end
+
+    def replacement
+      @json["filter"]["replacement"]
+    end
+
+    def matched?
+      @json["filter"]["matched"]
+    end
+
+    def matches
+      @json["filter"]["matches"].map { |match| OpenStruct.new(match) }
+    end
+    
+  end
+end

data/spec/lib/filter8/client_spec.rb

@@ -0,0 +1,75 @@
+require 'spec_helper'
+
+describe Filter8::Client do
+
+  before do
+    Timecop.freeze(Time.local(2014, 1, 1))
+  end
+
+  let(:client) {Filter8::Client.new(api_key: "12345", api_secret: "abcde")}
+
+  describe "#initialization" do
+    it "will configure a new client with the given parameters" do
+      expect(client.api_key).to eq "12345"
+      expect(client.api_secret).to eq "abcde"
+    end
+  end
+
+  describe "#send_request" do
+    let(:faraday_response) {double("Faraday::Response", body: { "test" => "response" }.to_json, status: 200)}
+    let(:faraday_connection) {double("Faraday::Connection", basic_auth: nil, post: faraday_response)}
+    let(:filter8_request) {double("Filter8::Request", request_params: { "test" => "data" })}
+
+    before do
+      Faraday.stub(:new).and_return(faraday_connection)
+    end
+
+    it "will correctly configure a new farady-connection to the filter8-server" do
+      expect(Faraday).to receive(:new).with(:url => 'https://api.filter8.com').and_return(faraday_connection)
+      client.send_request(filter8_request)
+    end
+
+    it "will use basic-auth with the api_key and the calculated password" do
+      expect(faraday_connection).to receive(:basic_auth).with(client.api_key, client.password)
+      client.send_request(filter8_request)
+    end
+
+    it "will send the given filter8_requests form-data via post" do
+      expect(faraday_connection).to receive(:post).with("/content/item.js?#{client.nonce_param}", filter8_request.request_params)
+      client.send_request(filter8_request)
+    end
+
+    it "will parse the response as JSON and return the result" do
+      expect(client.send_request(filter8_request)).to eq({ "test" => "response" })
+    end
+
+  end
+
+  describe "#timestamp" do
+    it "will return the current Time as a unix-timestamp" do
+      expect(client.timestamp).to eq Time.local(2014, 1, 1).to_i.to_s
+    end
+
+    it "will return the same value every time it is asked" do
+      Timecop.return
+
+      timestamp = client.timestamp
+      sleep 1.0/10
+
+      expect(client.timestamp).to eq timestamp
+    end
+  end
+
+  describe "#password" do
+    it "will return a md5-digested combination of nonce and api_secret" do
+      expect(client.password).to eq Digest::MD5.hexdigest("#{client.timestamp}#{client.api_secret}")
+    end
+  end
+
+  describe "#nonce_param" do
+    it "will return the nonce-param with the clients timestamp" do
+      expect(client.nonce_param).to eq "nonce=#{client.timestamp}"
+    end
+  end
+
+end

data/spec/lib/filter8/request_spec.rb

@@ -0,0 +1,73 @@
+require 'spec_helper'
+
+describe Filter8::Request do
+
+  describe "#initialization" do
+
+    it "will configure a new request with no options" do
+      expect(Filter8::Request.new("fuck")).to be_a Filter8::Request
+    end
+
+    it "will not be initializable without a content" do
+      expect{Filter8::Request.new}.to raise_error
+    end
+
+    it "will translate only options into content and options" do
+      request = Filter8::Request.new(content: "fuck", blacklist: "test")
+      expect(request.content).to eq "fuck"
+      expect(request.blacklist).to eq "test"
+    end
+
+    it "will raise an error when only options and no content is given" do
+      expect{Filter8::Request.new(blacklist: "test")}.to raise_error
+    end
+
+    it "will allow valid filters as options" do
+      request = Filter8::Request.new("fuck", blacklist: "test")
+      expect(request.blacklist).to eq "test"
+    end
+
+    it "will NOT allow invalid filters as options" do
+      expect{Filter8::Request.new("fuck", some_filter: "test")}.to raise_error(Filter8::Exception)
+    end
+
+    it "will allow valid filters with valid options" do
+      request = Filter8::Request.new("fuck", blacklist: {locale: [:en, :de]})
+
+      expect(request.blacklist).to eq({enabled: true, locale: [:en, :de]})
+    end
+
+    it "will NOT allow valid filters with invalid options" do
+      expect{Filter8::Request.new("fuck", blacklist: {myarg: "test"})}.to raise_error(Filter8::Exception)
+    end
+
+    it "will allow filters to be disabled" do
+      request = Filter8::Request.new("fuck", blacklist: {enabled: false})
+
+      expect(request.blacklist).to eq({enabled: false})
+    end
+  end
+
+  describe "#request_params" do
+    it "will return the correct parameters, when no options are given" do
+      expect(Filter8::Request.new("fuck").request_params).to eq "content=fuck"
+    end
+
+    it "will return the correct parameters, when one option with a single value is given" do
+      expect(Filter8::Request.new("fuck", blacklist: "test").request_params).to eq "content=fuck&blacklist=test"
+    end
+
+    it "will return the correct parameters, when one option with a hash is given" do
+      expect(Filter8::Request.new("fuck", blacklist: {locale: :en}).request_params).to eq "content=fuck&blacklist.enabled=true&blacklist.locale=en"
+    end
+
+    it "will return the correct parameters, when one option with a multiple value is given" do
+      expect(Filter8::Request.new("fuck", blacklist: {locale: [:en, :de]}).request_params).to eq "content=fuck&blacklist.enabled=true&blacklist.locale=en&blacklist.locale=de"
+    end
+
+    it "will return the correct parameters, when multiple options with a multiple values are given" do
+      expect(Filter8::Request.new("fuck", blacklist: {locale: [:en, :de]}, characters: {character: ["a", "b", "c"]}).request_params).to eq "content=fuck&blacklist.enabled=true&blacklist.locale=en&blacklist.locale=de&characters.enabled=true&characters.character=a&characters.character=b&characters.character=c"
+    end
+  end
+
+end

data/spec/lib/filter8/result_spec.rb

@@ -0,0 +1,110 @@
+require 'spec_helper'
+
+describe Filter8::Result do
+
+  it "will have a way to access the json-result directly" do
+    result = Filter8::Result.new({"test" => "result"})
+    expect(result.json).to eq({"test" => "result"})
+  end
+
+  context "when initialized with an empty filter8-response" do
+    let(:response_without_results) do
+      {
+        "filter" => {
+          "matched" => false,
+          "matches" => [
+          ],
+        "replacement" => "Fuck this motherfucking fuck shit!"
+        }
+      }
+    end
+    let(:result) { Filter8::Result.new(response_without_results) }
+
+    it "will state that there were no matches" do
+      expect(result.matched?).to be_false
+    end
+
+    it "will return no matches" do
+      expect(result.matches).to eq []
+    end
+  end
+
+  context "when initialized with a blacklist filter8-response" do
+    let(:response_with_blacklist_results) do
+      {
+        "filter" => {
+              "matched" => true,
+              "matches" => [
+            {
+                 "start" => 0,
+                "length" => 4,
+                  "type" => "blacklist",
+                  "tags" => [
+                  "Vulgarity"
+              ],
+              "severity" => "severe",
+                "locale" => "en",
+               "matched" => "fuck",
+                  "root" => "fuck",
+               "quality" => 1.0
+            },
+            {
+                 "start" => 10,
+                "length" => 13,
+                  "type" => "blacklist",
+                  "tags" => [
+                "Vulgarity"
+              ],
+              "severity" => "severe",
+                "locale" => "en",
+               "matched" => "fucking",
+                  "root" => "fuck",
+               "quality" => 1.0
+            },
+            {
+                 "start" => 24,
+                "length" => 4,
+                  "type" => "blacklist",
+                  "tags" => [
+                "Vulgarity"
+              ],
+              "severity" => "severe",
+                "locale" => "en",
+               "matched" => "fuck",
+                  "root" => "fuck",
+               "quality" => 1.0
+            },
+            {
+                 "start" => 29,
+                "length" => 4,
+                  "type" => "blacklist",
+                  "tags" => [
+                "Vulgarity"
+              ],
+              "severity" => "severe",
+                "locale" => "en",
+               "matched" => "shit",
+                  "root" => "shit",
+               "quality" => 1.0
+            }
+          ],
+          "replacement" => "**** this ************* **** ****!"
+        }
+      }
+    end
+    let(:result) { Filter8::Result.new(response_with_blacklist_results) }
+
+    it "will return the correct replacement" do
+      expect(result.replacement).to eq "**** this ************* **** ****!"
+    end
+
+    it "will state that there were matches" do
+      expect(result.matched?).to be_true
+    end
+
+    it "will return all matches" do
+      expect(result.matches).to eq(response_with_blacklist_results["filter"]["matches"].map { |match| OpenStruct.new(match) })
+    end
+  end
+
+end

data/spec/lib/filter8_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+
+describe Filter8 do
+
+  describe "#configure" do
+
+    before do
+      Filter8.configure do |config|
+        config.api_key = "12345"
+        config.api_secret = "abcde"
+      end
+    end
+
+    after do
+      Filter8.configuration = nil
+    end
+
+    it "will correctly retain it's configuration" do
+      expect(Filter8.configuration.api_key).to eq "12345"
+      expect(Filter8.configuration.api_secret).to eq "abcde"
+    end
+  end
+
+  describe "#filter" do
+    context "when not configured first" do
+      it "will raise an error and asks to configure first" do
+        expect{Filter8.filter("test", blacklist: "test")}.to raise_error(Filter8::Exception)
+      end
+    end
+    context "when correct configured first" do
+      let(:request) { double() }
+      let(:client) { double() }
+      let(:result) { double() }
+
+      before do
+        Filter8.configure do |config|
+          config.api_key = "12345"
+          config.api_secret = "abcde"
+        end
+      end
+
+      after do
+        Filter8.configuration = nil
+      end
+
+      it "will use the module-config to configure a client and send a request to filter8 with the given parameters. Returns the result" do
+        expect(Filter8::Client).to receive(:new).with(api_key: "12345", api_secret: "abcde").and_return(client)
+        expect(Filter8::Request).to receive(:new).with("test", blacklist: "test").and_return(request)
+        expect(client).to receive(:send_request).with(request).and_return(result)
+        expect(Filter8.filter("test", blacklist: "test")).to eq result
+      end
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,14 @@
+require "codeclimate-test-reporter"
+CodeClimate::TestReporter.start
+
+require 'filter8'
+require 'rspec'
+require 'timecop'
+
+RSpec.configure do |config|
+
+  config.after(:each) do
+    Timecop.return
+  end
+
+end

metadata

@@ -0,0 +1,138 @@
+--- !ruby/object:Gem::Specification
+name: filter8
+version: !ruby/object:Gem::Version
+  version: '0.9'
+platform: ruby
+authors:
+- Tim Adler
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-08-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 10.1.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 10.1.0
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.14.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.14.1
+- !ruby/object:Gem::Dependency
+  name: timecop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: codeclimate-test-reporter
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: An unofficial ruby wrapper for Filter8 (http://filter8.com). An API to
+  filter lots of stuff from texts, e.g. bad words.
+email: mail (at) toadle (dot) me
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- Gemfile
+- Gemfile.lock
+- README.md
+- Rakefile
+- filter8.gemspec
+- lib/filter8.rb
+- lib/filter8/client.rb
+- lib/filter8/exception.rb
+- lib/filter8/request.rb
+- lib/filter8/result.rb
+- spec/lib/filter8/client_spec.rb
+- spec/lib/filter8/request_spec.rb
+- spec/lib/filter8/result_spec.rb
+- spec/lib/filter8_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/toadle/filter8
+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.2.2
+signing_key: 
+specification_version: 4
+summary: An unofficial ruby wrapper for Filter8 (http://filter8.com). An API to filter
+  lots of stuff from texts, e.g. bad words.
+test_files:
+- spec/lib/filter8/client_spec.rb
+- spec/lib/filter8/request_spec.rb
+- spec/lib/filter8/result_spec.rb
+- spec/lib/filter8_spec.rb
+- spec/spec_helper.rb
+has_rdoc: