webpurify 0.5.0

data/.gitignore

@@ -0,0 +1,20 @@
+*.gem
+*.rbc
+.bundle
+.config
+coverage
+InstalledFiles
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+
+# YARD artifacts
+.yardoc
+_yardoc
+doc/
+
+test.rb

data/README.md

@@ -0,0 +1,170 @@
+WebPurify RubyGem
+=================
+
+This gem allows simple interaction with the WebPurify API using Ruby. For more information about WebPurify and the services it offers, check out http://webpurify.com/.
+
+
+### Commands
+
+##### Filters
+* [check](#check)
+* [check_count](#check_count)
+* [replace](#replace)
+* [return](#return)
+
+##### Blacklist
+* [add_to_blacklist](#add_to_blacklist)
+* [remove_from_blacklist](#remove_from_blacklist)
+* [get_blacklist](#get_blacklist)
+
+##### Whitelist
+* [add_to_whitelist](#add_to_whitelist)
+* [remove_from_whitelist](#remove_from_whitelist)
+* [get_whitelist](#get_whitelist)
+
+
+Install & Initialize
+--------------------
+
+`gem install WebPurify`
+
+or with bundler
+
+`gem WebPurify`
+
+`bundle install`
+
+Initialize with
+
+```rb
+@wp = WebPurify::Client.new('my_api_key')
+```
+
+or
+
+```rb
+@wp = WebPurify::Client.new({
+  api_key:    'my_api_key',
+  endpoint:   :us,    # can be :us, :eu, :ap (defaults to :us)
+  enterprise: false,  # true for ssl (default false, enterprise key required)
+})
+```
+
+Commands
+--------
+
+<a name="check" />
+### check
+
+Check a string of text for profanity. Returns true if profanity found, false if none.
+
+```rb
+puts @wp.check('some profane text')
+```
+
+
+<a name="check_count" />
+### check_count
+
+Check a string of text for profanity. Returns number of words if profanity found, 0 if none.
+
+```rb
+puts @wp.check_count('profane text')
+```
+
+
+<a name="replace" />
+### replace
+Check a string of text for profanity. Replaces any found profanity with a provided symbol, and returns the formatted string.
+
+```rb
+puts @wp.replace('profane text', '*')
+```
+
+
+<a name="return" />
+### return
+Check a string of text for profanity. If any found, returns an array of profane words. Else, returns empty array.
+
+```rb
+p @wp.return('profane text')
+```
+
+
+### Options
+All filter commands can take an additional options object, just before the callback. The available options are:
+
+```rb
+options = {
+  lang:   'en', # the 2 letter language code for the text you are submitting
+  semail: 1,    # treat email addresses like profanity
+  sphone: 1,    # treat phone numbers like profanity
+  slink:  1     # treat urls like profanity
+}
+
+puts @wp.check('some profane text', options)
+```
+
+
+<a name="add_to_blacklist" />
+### add_to_blacklist
+Add a word to the blacklist.
+
+```rb
+@wp.add_to_blacklist('my_awesome_word')
+```
+    
+For Deep search, add optional parameter 1 after word:
+
+```rb
+@wp.add_to_blacklist('my_awesome_word', 1)
+```
+
+
+<a name="remove_from_blacklist" />
+### remove_from_blacklist
+Remove a word from the blacklist.
+
+```rb
+@wp.remove_from_blacklist('my_awesome_word')
+```
+
+
+<a name="get_blacklist" />
+### get_blacklist
+Get the blacklist as an array of words.
+
+```rb
+p @wp.get_blacklist
+```
+
+
+<a name="add_to_whitelist" />
+### add_to_whitelist
+Add a word to the whitelist.
+
+```rb
+@wp.add_to_whitelist('my_awesome_word')
+```
+
+
+<a name="remove_from_whitelist" />
+### remove_from_whitelist
+Remove a word from the whitelist.
+
+```rb
+@wp.remove_from_whitelist('my_awesome_word')
+```
+
+
+<a name="get_whitelist" />
+### get_whitelist
+Get the whitelist as an array of words.
+
+```rb
+p @wp.get_whitelist
+```
+
+## To-do:
+* Handle error responses
+* Tests

data/lib/web_purify.rb

@@ -0,0 +1,12 @@
+require_relative 'web_purify/constants'
+require_relative 'web_purify/request'
+require_relative 'web_purify/client'
+
+# WebPurify Gem
+# @author Miles Zimmerman
+# 
+# The WebPurify gem provides easy access to the WebPurify API service. For more
+# information regarding WebPurify and the services it offers, check out
+# http://webpurify.com
+module WebPurify
+end

data/lib/web_purify/client.rb

@@ -0,0 +1,39 @@
+require_relative 'methods/filters'
+require_relative 'methods/blacklist'
+require_relative 'methods/whitelist'
+
+# WebPurify::Client
+#
+# The WebPurify::Client class maintains state of the request parameters like api_key, endpoint, etc.,
+# and provides easy methods for accessing WebPurify
+class WebPurify::Client
+  include WebPurify::Filters
+  include WebPurify::Blacklist
+  include WebPurify::Whitelist
+  
+  # Initialize the class
+  #
+  # @param options [String, Hash] Either an API key string, or a hash of options
+  def initialize(options)
+    if options.is_a? String
+      @api_key    = options
+      @endpoint   = :us
+      @enterprise = false
+    elsif options.is_a? Hash
+      @api_key    = options[:api_key]
+      @endpoint   = options[:endpoint]   || :us
+      @enterprise = options[:enterprise] || false
+    end
+
+    @request_base = {
+      :host   => WebPurify::Constants.endpoints[@endpoint],
+      :path   => WebPurify::Constants.rest_path,
+      :scheme => WebPurify::Constants.scheme(@enterprise)
+    }
+
+    @query_base = {
+      :api_key => @api_key,
+      :format  => WebPurify::Constants.format
+    }
+  end
+end

data/lib/web_purify/constants.rb

@@ -0,0 +1,65 @@
+module WebPurify
+  
+  # WebPurify::Constants
+  #
+  # WebPurify::Constants holds all the static variables used to access the API.
+  module Constants
+
+    # The various endpoints to access the API
+    #
+    # @return [Hash] A hash of the endpoints
+    def self.endpoints
+      return {
+        :us => 'api1.webpurify.com',
+        :eu => 'api1-eu.webpurify.com',
+        :ap => 'api1-ap.webpurify.com'
+      }
+    end
+    
+    
+    # Path appended to the endpoint URI
+    #
+    # @return [String] The rest path
+    def self.rest_path
+      return '/services/rest/'
+    end
+    
+    
+    # The response format
+    #
+    # @return [String] The format
+    def self.format
+      return 'json'
+    end
+    
+    
+    # Returns either http or https depending on whether enterprise mode
+    #   is selected.
+    #
+    # @param enterprise [Boolean] True if enterprise mode, false if not
+    # @return [String] The scheme, either http or https
+    def self.scheme(enterprise)
+      return enterprise ? 'https' : 'http'
+    end
+    
+    
+    # A hash for each API method
+    #
+    # @return [Hash] The method hash
+    def self.methods
+      return {
+        :check                 => 'webpurify.live.check',
+        :check_count           => 'webpurify.live.checkcount',
+        :replace               => 'webpurify.live.replace',
+        :return                => 'webpurify.live.return',
+        :add_to_blacklist      => 'webpurify.live.addtoblacklist',
+        :add_to_whitelist      => 'webpurify.live.addtowhitelist',
+        :remove_from_blacklist => 'webpurify.live.removefromblacklist',
+        :remove_from_whitelist => 'webpurify.live.removefromwhitelist',
+        :get_blacklist         => 'webpurify.live.getblacklist',
+        :get_whitelist         => 'webpurify.live.getwhitelist'
+      }
+    end
+
+  end
+end

data/lib/web_purify/methods/blacklist.rb

@@ -0,0 +1,54 @@
+module WebPurify
+  
+  # WebPurify::Blacklist
+  #
+  # Handles all methods related to the WebPurify Blacklist
+  module Blacklist
+    
+    # Add a word to the blacklist
+    #
+    # @param  word        [String]  The word to add to the blacklist
+    # @param  deep_search [Integer] 1 if deep search on word, otherwise 0 for not (default 0)
+    # @return             [Boolean] True if successful, false if not
+    def add_to_blacklist(word, deep_search=0)
+      params = {
+        :method => WebPurify::Constants.methods[:add_to_blacklist],
+        :word   => word,
+        :ds     => deep_search
+      }
+      parsed = WebPurify::Request.query(@request_base, @query_base, params)
+      return parsed[:success]=='1'
+    end
+    
+    
+    # Remove a word from the blacklist
+    #
+    # @param  word  [String]  The word to remove from the blacklist
+    # @return       [Boolean] True if successful, false if not
+    def remove_from_blacklist(word)
+      params = {
+        :method => WebPurify::Constants.methods[:remove_from_blacklist],
+        :word   => word
+      }
+      parsed = WebPurify::Request.query(@request_base, @query_base, params)
+      return parsed[:success]=='1'
+    end
+    
+    
+    # Get the blacklist
+    #
+    # @return [Array] An array of words in the blacklist
+    def get_blacklist
+      params = {
+        :method => WebPurify::Constants.methods[:get_blacklist]
+      }
+      parsed = WebPurify::Request.query(@request_base, @query_base, params)
+      if parsed[:word]
+        return [] << parsed[:word]
+      else
+        return []
+      end
+    end
+    
+  end
+end

data/lib/web_purify/methods/filters.rb

@@ -0,0 +1,70 @@
+module WebPurify
+  module Filters
+    
+    # Check for existence of profanity
+    #
+    # @param  text    [String]  Text to test for profanity
+    # @param  options [Hash]    Options hash, used to set additional parameters
+    # @return         [Boolean] True if text contains profanity, false if not
+    def check(text, options={})
+      params = {
+        :method => WebPurify::Constants.methods[:check],
+        :text   => text
+      }
+      parsed = WebPurify::Request.query(@request_base, @query_base, params.merge(options))
+      return parsed[:found]=='1'
+    end
+
+
+    # Check for existence of profanity and return number of profane words found
+    #
+    # @param  text    [String]  Text to test for profanity
+    # @param  options [Hash]    Options hash, used to set additional parameters
+    # @return         [Integer] The number of profane words found in text 
+    def check_count(text, options={})
+      params = {
+        :method => WebPurify::Constants.methods[:check_count],
+        :text   => text
+      }
+      parsed = WebPurify::Request.query(@request_base, @query_base, params.merge(options))
+      return parsed[:found].to_i
+    end
+
+
+    # Replace any matched profanity with provided symbol
+    #
+    # @param  text    [String]  Text to test for profanity
+    # @param  symbol  [String]  The symbol to replace each character of matched profanity
+    # @param  options [Hash]    Options hash, used to set additional parameters
+    # @return         [String]  The original text, replaced with the provided symbol
+    def replace(text, symbol, options={})
+      params = {
+        :method => WebPurify::Constants.methods[:replace],
+        :text   => text,
+        :replacesymbol => symbol
+      }
+      parsed = WebPurify::Request.query(@request_base, @query_base, params.merge(options))
+      return parsed[:text]
+    end
+    
+    
+    # Return an array of matched profanity
+    #
+    # @param  text    [String]  Text to test for profanity
+    # @param  options [Hash]    Options hash, used to set additional parameters
+    # @return         [Array]   The array of matched profane words
+    def return(text, options={})
+      params = {
+        :method => WebPurify::Constants.methods[:return],
+        :text   => text
+      }
+      parsed = WebPurify::Request.query(@request_base, @query_base, params.merge(options))
+      if parsed[:expletive]
+        return [] << parsed[:expletive]
+      else
+        return []
+      end
+    end
+    
+  end
+end

data/lib/web_purify/methods/whitelist.rb

@@ -0,0 +1,52 @@
+module WebPurify
+  
+  # WebPurify::Whitelist
+  #
+  # Handles all methods related to the WebPurify whitelist
+  module Whitelist
+    
+    # Add a word to the whitelist
+    #
+    # @param  word  [String]  The word to add to the whitelist
+    # @return       [Boolean] True if successful, false if not
+    def add_to_whitelist(word)
+      params = {
+        :method => WebPurify::Constants.methods[:add_to_whitelist],
+        :word   => word
+      }
+      parsed = WebPurify::Request.query(@request_base, @query_base, params)
+      return parsed[:success]=='1'
+    end
+    
+    
+    # Remove a word from the whitelist
+    #
+    # @param  word  [String]  The word to remove from the whitelist
+    # @return       [Boolean] True if successful, false if not
+    def remove_from_whitelist(word)
+      params = {
+        :method => WebPurify::Constants.methods[:remove_from_whitelist],
+        :word   => word
+      }
+      parsed = WebPurify::Request.query(@request_base, @query_base, params)
+      return parsed[:success]=='1'
+    end
+    
+    
+    # Get the whitelist
+    #
+    # @return [Array] An array of words in the whitelist
+    def get_whitelist
+      params = {
+        :method => WebPurify::Constants.methods[:get_whitelist]
+      }
+      parsed = WebPurify::Request.query(@request_base, @query_base, params)
+      if parsed[:word]
+        return [] << parsed[:word]
+      else
+        return []
+      end
+    end
+    
+  end
+end

data/lib/web_purify/request.rb

@@ -0,0 +1,62 @@
+require 'uri'
+require 'net/http'
+require 'net/https'
+require 'json'
+
+module WebPurify
+  
+  # WebPurify::Request
+  #
+  # WebPurify::Request handles the HTTP/HTTPS queries to the API endpoints,
+  # converting returned JSON into a usable object.
+  module Request
+    
+    WRAPPER = :rsp
+
+
+    # Converts a hash of key/values into a url-ready query string
+    #
+    # @param hash [Hash] The hash to be converted
+    # @return [String] The formatted query string
+    def self.to_query(hash)
+      parameters = []
+      hash.each {|k,v| parameters << "#{k}=#{v}" }
+      return URI.encode(parameters.join("&"))
+    end
+    
+    
+    # Executes a query to the API endpoint
+    #
+    # @param request_base [Hash] The base parameters for the request (comes from WebPurify::Client initialize())
+    # @param query_base   [Hash] The base parameters for the query (api_key, format)
+    # @param params       [Hash] The unique query parameters
+    # @return             [Hash] A hash parsed from the JSON response
+    def self.query(request_base, query_base, params)
+      q = query_base.merge(params)
+      uri_builder = (request_base[:scheme]=='https') ? URI::HTTPS : URI::HTTP
+      uri = uri_builder.build(
+        :host  => request_base[:host],
+        :path  => request_base[:path], 
+        :query => WebPurify::Request.to_query(q)
+      )
+      return JSON.parse(WebPurify::Request.get(uri, request_base[:scheme]), :symbolize_names => true)[WRAPPER]
+    end
+
+    
+    # Handles making the query according to http or https scheme
+    #
+    # @param uri    [String] The uri to be queried
+    # @param scheme [String] The scheme (http, https)
+    # @return       [String] The JSON request response
+    def self.get(uri, scheme)
+      req = (scheme=='https') ? Net::HTTPS : Net::HTTP
+      begin
+        request = req.get(uri)
+      rescue Exception => e
+        p e
+      end
+      return request
+    end
+
+  end
+end

data/lib/web_purify/version.rb

@@ -0,0 +1,3 @@
+module WebPurify
+  VERSION = "0.5.0"
+end

data/web_purify.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'web_purify/version'
+
+Gem::Specification.new do |s|
+  s.name        = "webpurify"
+  s.version     = WebPurify::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Miles Zimmerman"]
+  s.email       = ["miles@zserver.org"]
+  s.homepage    = "https://github.com/mileszim/webpurify-gem"
+  s.summary     = %q{A RubyGem for interfacing with the WebPurify API.}
+  s.description = %q{A RubyGem for interfacing with the WebPurify API.}
+
+  s.add_development_dependency "rspec", "~>2.5.0"
+  
+  s.add_dependency "json"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

metadata

@@ -0,0 +1,89 @@
+--- !ruby/object:Gem::Specification
+name: webpurify
+version: !ruby/object:Gem::Version
+  version: 0.5.0
+  prerelease: 
+platform: ruby
+authors:
+- Miles Zimmerman
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-06-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.5.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.5.0
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A RubyGem for interfacing with the WebPurify API.
+email:
+- miles@zserver.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- README.md
+- lib/web_purify.rb
+- lib/web_purify/client.rb
+- lib/web_purify/constants.rb
+- lib/web_purify/methods/blacklist.rb
+- lib/web_purify/methods/filters.rb
+- lib/web_purify/methods/whitelist.rb
+- lib/web_purify/request.rb
+- lib/web_purify/version.rb
+- web_purify.gemspec
+homepage: https://github.com/mileszim/webpurify-gem
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: A RubyGem for interfacing with the WebPurify API.
+test_files: []
+has_rdoc: