possible_email 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: e7c59b28497e97a707ccef97030b2ba5c71f5902
+  data.tar.gz: 7545a313b3364563cbad881f5bc3620ecaaccb7c
+SHA512:
+  metadata.gz: d4a1ecc7e3e67f6ffa3b35a2b424319877a61e9bfde31b3907769a860412f2de3f4a12065be4e952b9fb26a4bbfc5524a1e8301a4b22ae14459adfea05145d1a
+  data.tar.gz: 2c4657ce20186cf5d03416e02347257af0b127b2d49aa5015280233c65a4c9dedd8bffc420ddf7638bc21e2b746058810929834f37a6ce7991f48d2231e23d11

data/.coveralls.yml

@@ -0,0 +1 @@
+service_name: travis-ci

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rspec

@@ -0,0 +1,3 @@
+--color
+--warnings
+--require spec_helper

data/.travis.yml

@@ -0,0 +1,6 @@
+language: ruby
+cache: bundler
+rvm:
+  - 2.1.0
+  - 2.0.0
+  - 1.9.3

data/Gemfile

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

data/Guardfile

@@ -0,0 +1,11 @@
+guard :bundler do
+  watch('Gemfile')
+  watch(/^.+\.gemspec/)
+end
+
+guard :rspec, cmd: 'bundle exec rspec' do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/lib/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { "spec" }
+end
+

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Patrick Perey
+
+MIT License
+
+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,161 @@
+PossibleEmail
+=========
+A Ruby Gem to find someone's possible email address using their first name, last name, and domain.
+
+[![Gem Version](https://badge.fury.io/rb/possible_email.svg)](http://badge.fury.io/rb/possible_email)
+[![Build Status](https://travis-ci.org/the4dpatrick/possible-email.svg?branch=master)](https://travis-ci.org/the4dpatrick/possible-email)
+[![Coverage Status](https://coveralls.io/repos/the4dpatrick/possible-email/badge.png?branch=master)](https://coveralls.io/r/the4dpatrick/possible-email?branch=master)
+[![Code Climate](https://codeclimate.com/github/the4dpatrick/possible-email/badges/gpa.svg)](https://codeclimate.com/github/the4dpatrick/possible-email)
+
+More information in my [blog post](http://patrickperey.com/possible-email "blog post") at [PatrickPerey.com](http://patrickperey.com "Patrick Perey Blog")
+
+Installation
+------------
+Install the gem:
+
+```
+$ gem install possible_email
+```
+
+Basic Usage
+-----
+
+### Command Line Interface
+
+
+Enter target's first name, last name, and possible domain name into the terminal using `search`
+
+```
+$ possible_email search first_name last_name domain
+```
+
+Not sure about the domain name? Just add multiple domains at the end
+
+```
+$ possible_email search first_name last_name gmail.com, yahoo.com, live.com
+```
+
+
+Just want to Confirm a single email address? Use `find_profile`
+
+```
+$ possible_email find_profile test@example.com
+```
+Multiple email address? Same `find_profile`
+
+```
+$ possible_email find_profile test@example.com test1@example.com
+```
+### Ruby
+
+```ruby
+require 'possible_email'
+
+profiles = PossibleEmail.search('Kevin', 'Rose', 'gmail.com')
+profiles #=> "#<PossibleEmail::Response>"
+first_profile = profiles.first
+
+first_profile.name #=> 'Kevin Rose'
+first_profile.email #=> 'kevinrose@gmail.com'
+first_profile.location #=> 'San Francisco Bay Area'
+```
+Documentation
+-------------
+### PossibleEmail
+
+Available methods:
+
+**search(first_name, last_name, *domain)**
+
+Accepts three arguments `first_name`, `last_name`, and `domain`. PossibleEmail will use these three arguments to generate possible email addresses based on common email address patterns. PossibleEmail would then attempt to verify and return an email profile for each email address.
+
+```ruby
+# Single domain name
+PossibleEmail.search('bob', 'jones', 'gmail.com')
+
+# Multiple domain names as Strings
+PossibleEmail.search('bob', 'jones', 'gmail.com', 'yahoo.com')
+
+# Multiple domain names as an Array
+domains = ['gmail.com', 'yahoo.com', 'live.com']
+PossibleEmail.search('bob', 'jones', domains)
+```
+
+**find_profile(*emails)**
+
+Accepts a list of email address string arguments or an array. Instead of generating email addresses based on name arguments, PossibleEmail would attempt to verify and return an email profile for each email addresses passed into the method.
+
+```ruby
+# Comma-splitted email arguments
+PossibleEmail.find_profile('test@example.com', 'test1@example.com')
+
+# Array of emails
+PossibleEmail.find_profile(['test@example.com', 'test1@example.com'])
+```
+
+Both methods return a `PossibleEmail::Response` object. `PossibleEmail::Response` includes the `Enumerable` module, so all the methods you need to iterate through the profiles are available. The only exception when neither the `search` or `find_profile` is when there is only one profile within the response. In this case, the method returns the single Profile.
+
+### Profile
+
+Class for the associated data connnected with a specific email address.
+
+`Profile` attribute list:
+
+* `email` - Returns the profile's email address
+* `name` - Full name
+* `first_name` - First name
+* `last_name` - Last name
+* `friendly_name` - First name or named used to address this person
+* `location` - Location
+* `headline` - Short blurb about person
+* `success` - Type of response returned back from Rapportive API
+* `occupations` - Array of Occupation objects
+* `memberships` - Array of social network Membership objects
+* `images` - Array of Image objects
+
+### Occupation
+
+Class for person's jobs.
+
+`Occupation` attribute list:
+
+* `job_title` - Job title
+* `company` - Company
+
+### Membership
+
+Class for Social Network Accounts
+
+`Membership` attribute list:
+
+* `profile_url` - URL to person's website membership
+* `profile_id` - Website profile ID
+* `username` - Username
+* `site_name` - Name of the website membership
+
+### Image
+
+Class for images associated with email profile.
+
+`Image` attribute list:
+
+* `url` - Image url
+* `service` - Where the image is located
+* `url_proxied` - Rapportive image proxied URL
+
+Notes
+-----
+* With great power, comes great responsibly
+* Wrapper around the undocumented Rapportive API.
+* Valid results may be hidden due to API's limitations
+* Send Bitcoin `18fZ6muNmBrtENMZhnAjUw8eEsytmY8mZJ`
+
+
+Contributing
+------------
+
+1. Fork it ( http://github.com/the4dpatrick/possible-email )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,13 @@
+#!/usr/bin/env rake
+
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+desc "Run all specs"
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.rspec_opts = ['--color', '--format', 'nested']
+  t.pattern = 'spec/**/*_spec.rb'
+  t.verbose = false
+end
+
+task :default => :spec

data/bin/possible_email

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+
+require 'possible_email'
+require 'possible_email/cli'
+
+PossibleEmail::CLI.start(ARGV)

data/lib/possible_email.rb

@@ -0,0 +1,56 @@
+require 'possible_email/error'
+require 'possible_email/version'
+require 'possible_email/permutator'
+require 'possible_email/rapportive_requester'
+
+require 'httpi'
+require 'json'
+
+HTTPI.log = false
+
+EMAIL_REGEX = /^([\w\.%\+\-]+)@([\w\-]+\.)+([\w]{2,})$/i
+DOMAIN_REGEX = /^[^@]([\w\-]+\.)+([\w]{2,})$/
+NAME_REGEX = /^\b[a-zA-Z]+\b$/
+
+module PossibleEmail
+  class InvalidNameFormat < ArgumentError; end
+  class InvalidEmailFormat < ArgumentError; end
+
+  module_function
+
+  def search(first_name, last_name, *domain)
+    assign_instance_variables first_name, last_name, domain
+
+    fail InvalidNameFormat, "Name arguments were not formatted correctly #{[@first_name, @last_name, *@domain].inspect}" unless valid_names?
+
+    permutations = Permutator.call(@first_name, @last_name, @domain)
+    RapportiveRequester.request(permutations)
+  end
+
+  def find_profile(*emails)
+    @emails = emails.flatten
+
+    fail InvalidEmailFormat, "Email arguments were not formatted correctly #{@emails.inspect}" if invalid_emails?
+
+    RapportiveRequester.request(@emails)
+  end
+
+  private_class_method
+
+  def assign_instance_variables(first_name, last_name, domain)
+    @first_name = first_name
+    @last_name = last_name
+    @domain = domain.flatten
+  end
+
+  def invalid_emails?
+    @emails.any? { |email| email !~ EMAIL_REGEX }
+  end
+
+  def valid_names?
+    valid_domain = @domain.all? { |d| d =~ DOMAIN_REGEX }
+    valid_names = [@first_name, @last_name].all? { |n| n =~ NAME_REGEX }
+
+    valid_domain && valid_names
+  end
+end

data/lib/possible_email/cli.rb

@@ -0,0 +1,33 @@
+require 'thor'
+
+module PossibleEmail
+  class CLI < Thor
+    # possible_email search
+
+    desc 'search', 'Search for valid emails using first name, last name, and domain name'
+    long_desc <<-LONGDESC
+Takes in a first name, last name, and domain name.
+
+Domain name can be a single domain like 'gmail.com', or multiple domain names like 'gmail.com', 'yahoo.com'
+
+Prints out all of the found email profiles for valid email addresses with associated information
+LONGDESC
+
+    def search(first_name, last_name, *domain)
+      profiles = PossibleEmail.search(first_name, last_name, domain)
+      puts profiles
+    end
+
+    # possible_email find_profile
+
+    desc 'find_profile', 'return a profile for one or more email addresses'
+    long_desc <<-LONGDESC
+Prints out all of the found email profiles for valid email addresses with associated information
+LONGDESC
+
+    def find_profile(*emails)
+      profiles = PossibleEmail.find_profile(emails)
+      puts profiles
+    end
+  end
+end

data/lib/possible_email/error.rb

@@ -0,0 +1,3 @@
+module PossibleEmail
+
+end

data/lib/possible_email/patterns.rb

@@ -0,0 +1,38 @@
+PATTERNS = <<PATTERNS
+{first_name}@{domain}
+{last_name}@{domain}
+{first_initial}@{domain}
+{last_initial}@{domain}
+{first_name}{last_name}@{domain}
+{first_name}.{last_name}@{domain}
+{first_initial}{last_name}@{domain}
+{first_initial}.{last_name}@{domain}
+{first_name}{last_initial}@{domain}
+{first_name}.{last_initial}@{domain}
+{first_initial}{last_initial}@{domain}
+{first_initial}.{last_initial}@{domain}
+{last_name}{first_name}@{domain}
+{last_name}.{first_name}@{domain}
+{last_name}{first_initial}@{domain}
+{last_name}.{first_initial}@{domain}
+{last_initial}{first_name}@{domain}
+{last_initial}.{first_name}@{domain}
+{last_initial}{first_initial}@{domain}
+{last_initial}.{first_initial}@{domain}
+{first_name}-{last_name}@{domain}
+{first_initial}-{last_name}@{domain}
+{first_name}-{last_initial}@{domain}
+{first_initial}-{last_initial}@{domain}
+{last_name}-{first_name}@{domain}
+{last_name}-{first_initial}@{domain}
+{last_initial}-{first_name}@{domain}
+{last_initial}-{first_initial}@{domain}
+{first_name}_{last_name}@{domain}
+{first_initial}_{last_name}@{domain}
+{first_name}_{last_initial}@{domain}
+{first_initial}_{last_initial}@{domain}
+{last_name}_{first_name}@{domain}
+{last_name}_{first_initial}@{domain}
+{last_initial}_{first_name}@{domain}
+{last_initial}_{first_initial}@{domain}
+PATTERNS

data/lib/possible_email/permutator.rb

@@ -0,0 +1,64 @@
+require 'possible_email/patterns'
+
+module PossibleEmail
+  class Permutator
+    def self.call(first_name, last_name, *domain)
+      new(first_name, last_name, domain).call
+    end
+
+    def initialize(first_name, last_name, domain)
+      @first_name = first_name
+      @last_name = last_name
+      @domain = domain.flatten # HACK
+      @first_initial = first_name.chars.first
+      @last_initial = last_name.chars.first
+    end
+
+    def call
+      permutations = create_all_permutations
+      permutations
+    end
+
+    private
+
+    def create_all_permutations
+      @domain.reduce([]) do |permutations, domain|
+        substitute_pattern_placeholders_with_correct_values(domain)
+
+        separate_each_permutation(permutations)
+      end
+    end
+
+    def substitute_pattern_placeholders_with_correct_values(domain)
+      # reset after each domain iteration
+      @permutation_patterns = PATTERNS.dup
+
+      substitute_every_pattern_placeholder_except_domain
+
+      @permutation_patterns.gsub!('{domain}', domain)
+    end
+
+    def substitute_every_pattern_placeholder_except_domain
+      all_instance_variables_except_domain.each do |var|
+        @permutation_patterns.gsub!(placeholder(var), value_of(var))
+      end
+    end
+
+    def all_instance_variables_except_domain
+      instance_variables.dup - [:@domain]
+    end
+
+    def placeholder(var)
+      "{#{var.to_s[1..-1]}}"
+    end
+
+    def value_of(var)
+      instance_variable_get("@#{var[1..-1]}".to_sym)
+    end
+
+    def separate_each_permutation(permutations)
+      permutations << @permutation_patterns.split("\n")
+      permutations.flatten
+    end
+  end
+end