naughty_or_nice 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: cc80dcfb26cbb5c4c7eac6db2ac75d5a753c8b67
+  data.tar.gz: 3ca21738914b3859ce1cf48feeeb92ee83cc9372
+SHA512:
+  metadata.gz: b63b245920688a8b36b6b33bd2fd5d5bc18b558d5ca066882625da05aeb703dcaca9a1754a42cb30ead40f763b2425f9c40b2409934d3e27516946f5ea2f5cdc
+  data.tar.gz: b43c3c6c18074c5341c4d9185245580c276182ae845bc052c5587c6bfbe81aaed9a21c6ecb606f9245bc3366c455815ca3b6942ccc799ed09c1280889ab92b71

data/LICENSE.md

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Ben Balter
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,60 @@
+# Naughty or Nice
+
+Naughty or Nice simplifies the process of extracting domain information from a domain-like string (an email, a URL, etc.) and checking whether it meets criteria you specify.
+
+## Usage
+
+Naughty or Nice doesn't do too much on its own. Out of the box, it can extract a domain from a domain-like string, and can verify that it is, in fact, a valid domain. It does this by leveraging the power of the [Public Suffix List](http://publicsuffix.org/), and the associated [Ruby Gem](https://github.com/weppos/publicsuffix-ruby).
+
+The true power of Naughty or Nice comes when you extended it into a child class.
+
+## Extending Naughty or Nice
+
+Let's say you have a list of three domains, `foo.com`, `bar.com`, and `foobar.com`. You'd spec out a class like so:
+
+```ruby
+class Checker < NaughtyOrNice
+  DOMAINS = %w[foo.com bar.com foobar.com]
+
+  def valid?
+    DOMAINS.include? domain
+  end
+end
+```
+
+That's it! Just overwrite the `valid?` method and Naughty or Nice takes care of the rest.
+
+## Using the extended class
+
+There are a handful of magic methods that your child class automatically gets. You can throw any domain-like string at your new `Checker` class, and figure out if it's on the list. Here's a few examples:
+
+```ruby
+Checker.valid? "foo.com" #=> true
+Checker.valid? "foo.org" #=> false
+```
+
+Notice we're using the class method `valid?` That automatically calls `Checker.new(string).valid?` for you. Cool, huh?
+
+But you don't just need to give Checker crisp, clean domains. Let's get a bit trickier:
+
+```ruby
+Checker.valid? "http://foo.bar.com" #=> true
+Checker.valid? "foo@bar.com" #=> true
+Checker.valid? "foobar" => false
+```
+
+## Extracting domain information
+
+You can also you NaughtyOrNice to extract domain information for use elsewhere. Continuing our above example:
+
+```ruby
+address = Checker.new "baz@foo.bar.com"
+address.valid?           #=> true
+address.domain           #=> "foo.bar.com"
+address.domain_parts.tld #=> "com"
+address.domain_parts.sld #=> "bar"
+```
+
+## See it in action
+
+Take a look at [Gman](https://github.com/benbalter/gman) to see Naughty or Nice in action. Gman uses a crowd-sourced list of government domains to check if a given email address is a government email.

data/lib/naughty_or_nice.rb

@@ -0,0 +1,112 @@
+require 'public_suffix'
+require "addressable/uri"
+
+class NaughtyOrNice
+
+  class << self
+    def valid?(text)
+      self.new(text).valid?
+    end
+  end
+
+  # Source: http://bit.ly/1n2X9iv
+  EMAIL_REGEX = %r{
+        ^
+        (
+          [\w\!\#\$\%\&\'\*\+\-\/\=\?\^\`\{\|\}\~]+
+          \.
+        )
+        *
+        [\w\!\#\$\%\&\'\*\+\-\/\=\?\^\`\{\|\}\~]+
+        @
+        (
+          (
+            (
+              (
+                (
+                  [a-z0-9]{1}
+                  [a-z0-9\-]{0,62}
+                  [a-z0-9]{1}
+                )
+                |
+                [a-z]
+              )
+              \.
+            )+
+            [a-z]{2,6}
+          )
+          |
+          (
+            \d{1,3}
+            \.
+          ){3}
+          \d{1,3}
+          (
+            \:\d{1,5}
+          )?
+        )
+        $
+      }xi
+
+  def initialize(text)
+    @text = text.to_s.downcase.strip
+  end
+
+  # Parse the domain from the input string
+  #
+  # Can handle urls, domains, or emails
+  #
+  # Returns the domain string
+  def domain
+    @domain ||= begin
+      return nil if @text.empty?
+
+      uri = Addressable::URI.parse(@text)
+
+      if uri.host # valid https?://* URI
+        uri.host
+      elsif email?
+        @text.match(/@([\w\.\-]+)\Z/i)[1]
+      else # url sans http://
+        begin
+          uri = Addressable::URI.parse("http://#{@text}")
+          # properly parse http://foo edge cases
+          # see https://github.com/sporkmonger/addressable/issues/145
+          uri.host if uri.host =~ /\./
+        rescue Addressable::URI::InvalidURIError
+          nil
+        end
+      end
+    end
+  end
+  alias_method :to_s, :domain
+
+  # Checks if the input string represents a valid domain
+  #
+  # Returns boolean true if a valid domain, otherwise false
+  def valid?
+    PublicSuffix.valid?(domain)
+  end
+
+  # Is the input text in the form of a valid email address?
+  #
+  # Returns true if email, otherwise false
+  def email?
+    !!(@text =~ EMAIL_REGEX)
+  end
+
+  # Helper function to return the public suffix domain object
+  #
+  # Supports all domain strings (URLs, emails)
+  #
+  # Returns the domain object or nil, but no errors, never an error
+  def domain_parts
+    PublicSuffix.parse domain
+  rescue PublicSuffix::DomainInvalid
+    nil
+  end
+
+  def inspect
+    "#<#{self.class} domain=\"#{domain}\" valid=#{valid?}>"
+  end
+end

metadata

@@ -0,0 +1,49 @@
+--- !ruby/object:Gem::Specification
+name: naughty_or_nice
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Ben Balter
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-09-18 00:00:00.000000000 Z
+dependencies: []
+description: Naughty or Nice simplifies the process of extracting domain information
+  from a domain-like string (an email, a URL, etc.) and checking whether it meets
+  criteria you specify.
+email: ben.balter@github.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.md
+- README.md
+- lib/naughty_or_nice.rb
+homepage: http://github.com/benbalter/naughty_or_nice
+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.0
+signing_key: 
+specification_version: 4
+summary: You've made the list. We'll help you check it twice. Given a domain-like
+  string, verifies inclusion in a list you provide.
+test_files: []