emailhunter 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: aa2d9e9cc40ed470a2704f6cb875ade4b23bfb3f256ea535fc9ec772aa6d36f7
-  data.tar.gz: b16e0822b7b5362ac3ce01435467db482dd867d97abd9a394b40394c7f67989a
+  metadata.gz: b4783ca3e6457c776875732582c772c3d1d112934384922f9816f22a401107b0
+  data.tar.gz: 2a12c9cb64c3ad77b9e902d0113ddc68b4c56c04c0530aa21e72b02523f9f58b
 SHA512:
-  metadata.gz: 119c49c0e20229684a533a5bd000c33b5ba7470d2bc0ddcb075bfab48b705b1f0fe84e59227e2ed621c4ec27b335328189d7920b9db80037a5ad674864f94c22
-  data.tar.gz: 1de4508d1b3289004fe3a5603e48c2f03ce1b5cd4334c6a2b2efcf846e52a4f9966a2224639a342d790f0bd05b1adbcb5e322358567cae8d979930e526d7f6f4
+  metadata.gz: 5e2b5c05259327cd62ceef07587518f755e57d4d577fff2bd4f38f1afba24b920d7d8ab0528ac27d86c80d53e4bdd3984a0a7d992a2d26d7f30141945b06bc32
+  data.tar.gz: 1ab01074fbe447ad24b2d39ce89bdf444b0b2cbdf280a615b94a17642bc350147135468d2651a7558fb00f6dc2cf271ca946e0291e3f5529d500d12bbc3f71d2

data/README.md

@@ -1,8 +1,6 @@
-# Emailhunter
+# EmailHunter
 
-A tiny ruby wrapper around Hunter (former Email Hunter) API. Direct access to all the web's email addresses.
-
-UPDATE (2016-12-02): gem updated with V2 API.
+A lightweight Ruby wrapper around Hunter (formerly Email Hunter) API, providing direct access to email search, verification, and company insights.
 
 ## Installation
 
@@ -12,30 +10,37 @@ Add this line to your application's Gemfile:
 gem 'emailhunter'
 ```
 
-And then execute:
+Then execute:
 
-    $ bundle
+```sh
+$ bundle install
+```
 
-Or install it yourself as:
+Or install it yourself with:
 
-    $ gem install emailhunter
+```sh
+$ gem install emailhunter
+```
 
 ## Usage
 
 ```ruby
 require 'emailhunter'
-email_hunter = EmailHunter.new('Your secret API key')
-
+email_hunter = EmailHunter.new('Your API Key')
 ```
-Your secret API key. You can generate it in your dashboard from https://hunter.io
 
-## Domain search API
-Returns all the email addresses found using one given domain name, with our sources.
+Your API key can be generated in your [Hunter dashboard](https://hunter.io).
+
+## Features
+
+### 1. Domain Search API
+Retrieve all email addresses associated with a given domain.
+
 ```ruby
 result = email_hunter.search('stripe.com')
 ```
 
-## Accessing domain search response
+#### Response Fields:
 ```ruby
 result.fetch(:meta)
 result.fetch(:webmail)
@@ -43,13 +48,15 @@ result.fetch(:emails)
 result.fetch(:pattern)
 result.fetch(:domain)
 ```
-## Email Verify API
-Allows you to verify the deliverability of an email address.
+
+### 2. Email Verification API
+Check the deliverability of an email address.
+
 ```ruby
-email_hunter.verify('bonjour@firmapi.com')
+result = email_hunter.verify('bonjour@firmapi.com')
 ```
 
-## Accessing email verify response
+#### Response Fields:
 ```ruby
 result.fetch(:result)
 result.fetch(:score)
@@ -62,33 +69,16 @@ result.fetch(:smtp_check)
 result.fetch(:accept_all)
 result.fetch(:sources)
 result.fetch(:meta)
-
 ```
 
-## Email Exist API (only for V1)
-This API call is deprecated, please use the email verification call instead.
-
-
-This API endpoint allows you to check if a given email address has been found on the web. If it has been found, it returns all the sources with the dates of the last crawls.
+### 3. Email Finder API
+Guess the most likely email of a person using their first name, last name, and domain.
 
 ```ruby
-email_hunter.exist('bonjour@firmapi.com')
+result = email_hunter.finder('gmail.com', 'Davide', 'Santangelo')
 ```
 
-## Accessing email verify response
-```ruby
-result.status
-result.email
-result.exist
-result.sources
-```
-
-## Finder API (legacy generate)
-Guesses the most likely email of a person from his first name, his last name and a domain name.
-```ruby
-email_hunter.finder('gmail.com', 'Davide', 'Santangelo')
-```
-## Accessing finder response
+#### Response Fields:
 ```ruby
 result.fetch(:email)
 result.fetch(:score)
@@ -97,55 +87,85 @@ result.fetch(:domain)
 result.fetch(:meta)
 ```
 
-## Count API
-Returns the number of email addresses found for a domain. This is a FREE API call.
+### 4. Count API
+Retrieve the number of email addresses associated with a domain (FREE API call).
+
 ```ruby
-email_hunter.count('gmail.com')
+result = email_hunter.count('gmail.com')
 ```
 
-## Accessing count response
+#### Response Fields:
 ```ruby
 result.fetch(:data)
 result.fetch(:meta)
 ```
 
-## Account Information
-This method enables you to get information regarding your Hunter account at any time. This call is free.
+### 5. Company Information API (New Feature)
+Retrieve company details using a domain name.
+
 ```ruby
-email_hunter.account
+result = email_hunter.company('stripe.com')
 ```
 
-## Accessing account response
+#### Response Fields:
 ```ruby
-result.fetch(:data)
+result.fetch(:name)
+result.fetch(:industry)
+result.fetch(:employees)
+result.fetch(:country)
+result.fetch(:meta)
 ```
 
+### 6. People Search API (New Feature)
+Retrieve key individuals associated with a company based on a domain name.
+
+```ruby
+result = email_hunter.people('stripe.com')
+```
+
+#### Response Fields:
+```ruby
+result.fetch(:employees)
+result.fetch(:position)
+result.fetch(:email)
+result.fetch(:meta)
+```
+
+### 7. Account Information API
+Retrieve details about your Hunter account.
+
+```ruby
+result = email_hunter.account
+```
+
+#### Response Example:
 ```json
-{  
-   "data":{  
-      "first_name":"Davide",
-      "last_name":"Santangelo",
-      "email":"davide.santangelo@gmail.com",
-      "plan_name":"Free",
-      "plan_level":0,
-      "reset_date":"2019-06-29",
-      "team_id":349,
-      "calls":{  
-         "used":4,
-         "available":50
+{
+   "data": {
+      "first_name": "Davide",
+      "last_name": "Santangelo",
+      "email": "davide.santangelo@gmail.com",
+      "plan_name": "Free",
+      "plan_level": 0,
+      "reset_date": "2025-06-29",
+      "team_id": 349,
+      "calls": {
+         "used": 4,
+         "available": 50
       }
    }
 }
 ```
 
 ## License
-The emailhunter GEM is released under the MIT License.
 
+The EmailHunter gem is released under the [MIT License](https://opensource.org/licenses/MIT).
 
 ## Contributing
 
-1. Fork it ( https://github.com/[my-github-username]/emailhunter/fork )
+1. Fork it ( https://github.com/[your-github-username]/emailhunter/fork )
 2. Create your feature branch (`git checkout -b my-new-feature`)
-3. Commit your changes (`git commit -am 'Add some feature'`)
+3. Commit your changes (`git commit -am 'Add new feature'`)
 4. Push to the branch (`git push origin my-new-feature`)
 5. Create a new Pull Request
+

data/emailhunter.gemspec

@@ -1,6 +1,5 @@
-lib = File.expand_path('lib', __dir__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require File.expand_path('lib/email_hunter/version', __dir__)
+# Use require_relative to load the version file
+require_relative 'lib/email_hunter/version'
 
 Gem::Specification.new do |spec|
   spec.name          = 'emailhunter'
@@ -8,23 +7,36 @@ Gem::Specification.new do |spec|
   spec.authors       = ['Davide Santangelo']
   spec.email         = ['davide.santangelo@gmail.com']
 
-  spec.summary       = 'A tiny ruby wrapper around Hunter.io API '
-  spec.description   = 'A tiny ruby wrapper around Hunter.io API. Hunter.io helps sales people reach their targets and increase their sales. '
+  spec.summary       = 'A tiny Ruby wrapper around the Hunter.io API'
+  spec.description   = <<~DESC
+    EmailHunter is a minimalistic Ruby wrapper for the Hunter.io API.
+    It provides a straightforward interface to integrate Hunter.io's
+    email discovery capabilities into your sales and marketing workflows.
+  DESC
   spec.license       = 'MIT'
+  
+  # Adding additional metadata improves discoverability
+  spec.homepage      = 'https://github.com/davidesantangelo/emailhunter'
+  spec.metadata      = {
+    "source_code_uri" => "https://github.com/davidesantangelo/emailhunter"
+  }
 
-  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  # Automatically include all version-controlled files except tests and specs
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f =~ %r{^(test|spec|features)/} }
   spec.bindir        = 'exe'
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ['lib']
 
+  # Development dependencies
   spec.add_development_dependency 'bundler', '~> 2.1'
   spec.add_development_dependency 'rake', '~> 10.0'
   spec.add_development_dependency 'rspec'
   spec.add_development_dependency 'typhoeus'
   spec.add_development_dependency 'vcr'
 
-  spec.required_ruby_version = '>= 1.9.3'
+  spec.required_ruby_version = '>= 3.0.0'
 
+  # Runtime dependencies
   spec.add_dependency 'faraday'
   spec.add_dependency 'json'
 end

data/lib/email_hunter/account.rb

@@ -3,10 +3,10 @@
 require 'faraday'
 require 'json'
 
-API_ACCOUNT_URL = 'https://api.hunter.io/v2/account?'
-
 module EmailHunter
   class Account
+    API_URL = 'https://api.hunter.io/v2/account'
+    
     attr_reader :result, :first_name, :last_name, :email, :plan_name, :plan_level, :reset_date, :team_id, :calls,
                 :requests
 
@@ -15,15 +15,24 @@ module EmailHunter
     end
 
     def hunt
-      response = apiresponse
-      Struct.new(*response.keys).new(*response.values) unless response.empty?
+      response = fetch_account_data
+      parse_response(response)
     end
 
     private
 
-    def apiresponse
-      response = Faraday.new("#{API_ACCOUNT_URL}&api_key=#{@key}").get
-      response.success? ? JSON.parse(response.body, { symbolize_names: true }) : []
+    def fetch_account_data
+      connection = Faraday.new
+      connection.get(API_URL, api_key: @key)
+    end
+
+    def parse_response(response)
+      return nil unless response.success?
+      
+      data = JSON.parse(response.body, symbolize_names: true)
+      return nil if data.empty?
+      
+      Struct.new(*data.keys).new(*data.values)
     end
   end
 end

data/lib/email_hunter/api.rb

@@ -2,14 +2,12 @@
 
 require 'uri'
 
-require File.expand_path(File.join(File.dirname(__FILE__), 'exist'))
-require File.expand_path(File.join(File.dirname(__FILE__), 'search'))
-require File.expand_path(File.join(File.dirname(__FILE__), 'finder'))
-require File.expand_path(File.join(File.dirname(__FILE__), 'verify'))
-require File.expand_path(File.join(File.dirname(__FILE__), 'count'))
-require File.expand_path(File.join(File.dirname(__FILE__), 'account'))
+%w[exist search finder verify count account company people].each do |file|
+  require_relative file
+end
 
 module EmailHunter
+  # Main API client for EmailHunter services
   class Api
     attr_reader :key
 
@@ -19,17 +17,17 @@ module EmailHunter
 
     # Domain search API
     def search(domain, params = {})
-      EmailHunter::Search.new(domain, key, params).hunt
+      execute_hunt(Search, domain, params)
     end
 
     # Email exist API
     def exist(email)
-      EmailHunter::Exist.new(email, key).hunt
+      execute_hunt(Exist, email)
     end
 
     # Email verify API
     def verify(email)
-      EmailHunter::Verify.new(email, key).hunt
+      execute_hunt(Verify, email)
     end
 
     # Email Finder API
@@ -39,12 +37,45 @@ module EmailHunter
 
     # Email Count API
     def count(domain)
-      EmailHunter::Count.new(domain).hunt
+      execute_hunt(Count, domain)
     end
 
     # Account Information API
     def account
-      EmailHunter::Account.new(key).hunt
+      execute_hunt(Account)
+    end
+    
+    # Company Information API
+    def company(domain)
+      execute_hunt(Company, domain)
+    end
+
+    # People Information API
+    def people(domain)
+      execute_hunt(People, domain)
+    end
+
+    private
+
+    # Helper method to reduce repetition
+    def execute_hunt(klass, *args)
+      case klass.name.split('::').last
+      when 'Search'
+        # Search expects (domain, key, params)
+        domain, params = args
+        klass.new(domain, key, params || {}).hunt
+      when 'Count'
+        # Count doesn't need key
+        domain = args.first
+        klass.new(domain).hunt
+      when 'Account'
+        # Account only needs key
+        klass.new(key).hunt
+      else
+        # Other classes expect (value, key)
+        value = args.first
+        klass.new(value, key).hunt
+      end
     end
   end
 end

data/lib/email_hunter/company.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require 'faraday'
+require 'json'
+require 'ostruct'
+
+module EmailHunter
+  class Company
+    API_URL = 'https://api.hunter.io/v2/companies/find'
+    
+    attr_reader :domain, :key
+
+    def initialize(domain, key)
+      @domain = domain
+      @key = key
+    end
+
+    def hunt
+      response_data = fetch_company_data
+      return nil if response_data.empty?
+      
+      # Convert nested data structure to a Struct
+      data = response_data[:data]
+      meta = response_data[:meta]
+      
+      result = OpenStruct.new(
+        data: OpenStruct.new(data),
+        meta: OpenStruct.new(meta)
+      )
+      
+      # Recursively convert nested hashes to OpenStructs for deeper access
+      convert_hash_to_struct(result.data, data)
+      
+      result
+    end
+
+    private
+
+    def fetch_company_data
+      @fetch_company_data ||= begin
+        connection = Faraday.new
+        response = connection.get(API_URL, domain: domain, api_key: key)
+        
+        return {} unless response.success?
+
+        JSON.parse(response.body, symbolize_names: true)
+      end
+    end
+
+    def convert_hash_to_struct(struct, hash)
+      hash.each do |key, value|
+        if value.is_a?(Hash)
+          struct[key] = OpenStruct.new(value)
+          convert_hash_to_struct(struct[key], value)
+        elsif value.is_a?(Array) && value.first.is_a?(Hash)
+          struct[key] = value.map { |item| OpenStruct.new(item) }
+        end
+      end
+    end
+  end
+end

data/lib/email_hunter/count.rb

@@ -1,27 +1,35 @@
+# frozen_string_literal: true
+
 require 'faraday'
 require 'json'
 
-API_COUNT_URL = 'https://api.hunter.io/v2/email-count?'.freeze
-
 module EmailHunter
   class Count
-    attr_reader :data, :meta, :domain
+    API_URL = 'https://api.hunter.io/v2/email-count'
+    
+    attr_reader :domain
 
     def initialize(domain)
       @domain = domain
     end
 
     def hunt
-      Struct.new(*data.keys).new(*data.values)
+      response_data = fetch_count_data
+      return nil if response_data.empty?
+      
+      Struct.new(*response_data.keys).new(*response_data.values)
     end
 
-    def apiresponse
-      @data ||= begin
-        response = Faraday.new("#{API_COUNT_URL}domain=#{domain}").get
+    private
 
-        return [] unless response.success?
+    def fetch_count_data
+      @fetch_count_data ||= begin
+        connection = Faraday.new
+        response = connection.get(API_URL, domain: domain)
+        
+        return {} unless response.success?
 
-        JSON.parse(response.body, { symbolize_names: true })
+        JSON.parse(response.body, symbolize_names: true)
       end
     end
   end

data/lib/email_hunter/exist.rb

@@ -3,11 +3,11 @@
 require 'faraday'
 require 'json'
 
-API_EXIST_URL = 'https://api.emailhunter.co/v1/exist?'
-
 module EmailHunter
   class Exist
-    attr_reader :status, :email, :exist, :sources, :key
+    API_URL = 'https://api.emailhunter.co/v1/exist'
+    
+    attr_reader :email, :key
 
     def initialize(email, key)
       @email = email
@@ -15,16 +15,22 @@ module EmailHunter
     end
 
     def hunt
-      Struct.new(*data.keys).new(*data.values)
+      response_data = fetch_exist_data
+      return nil if response_data.empty?
+      
+      Struct.new(*response_data.keys).new(*response_data.values)
     end
 
-    def data
-      @data ||= begin
-        response = Faraday.new("#{API_EXIST_URL}email=#{email}&api_key=#{key}").get
+    private
 
+    def fetch_exist_data
+      @fetch_exist_data ||= begin
+        connection = Faraday.new
+        response = connection.get(API_URL, email: email, api_key: key)
+        
         return {} unless response.success?
 
-        JSON.parse(response.body, { symbolize_names: true })
+        JSON.parse(response.body, symbolize_names: true)
       end
     end
   end

data/lib/email_hunter/finder.rb

@@ -3,10 +3,10 @@
 require 'faraday'
 require 'json'
 
-API_FINDER_URL = 'https://api.hunter.io/v2/email-finder?'
-
 module EmailHunter
   class Finder
+    API_FINDER_URL = 'https://api.hunter.io/v2/email-finder'
+    
     attr_reader :email, :score, :sources, :domain, :meta, :key, :first_name, :last_name
 
     def initialize(domain, first_name, last_name, key)
@@ -22,12 +22,26 @@ module EmailHunter
 
     def data
       @data ||= begin
-        response = Faraday.new("#{API_FINDER_URL}domain=#{domain}&first_name=#{first_name}&last_name=#{last_name}&api_key=#{key}").get
-
-        return [] unless response.success?
+        response = fetch_finder_data
+        
+        return {} unless response.success?
 
-        JSON.parse(response.body, { symbolize_names: true })
+        JSON.parse(response.body, symbolize_names: true)
       end
     end
+
+    private
+
+    def fetch_finder_data
+      connection = Faraday.new
+      params = {
+        domain: domain,
+        first_name: first_name,
+        last_name: last_name,
+        api_key: key
+      }
+      
+      connection.get(API_FINDER_URL, params)
+    end
   end
 end

data/lib/email_hunter/people.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require 'faraday'
+require 'json'
+require 'ostruct'
+
+module EmailHunter
+  class People
+    API_URL = 'https://api.hunter.io/v2/people/find'
+    
+    attr_reader :email, :key
+
+    def initialize(email, key)
+      @email = email
+      @key = key
+    end
+
+    def hunt
+      response_data = fetch_people_data
+      return nil if response_data.empty?
+      
+      # Convert nested data structure to a Struct
+      data = response_data[:data]
+      meta = response_data[:meta]
+      
+      result = OpenStruct.new(
+        data: OpenStruct.new(data),
+        meta: OpenStruct.new(meta)
+      )
+      
+      # Recursively convert nested hashes to OpenStructs for deeper access
+      convert_hash_to_struct(result.data, data)
+      
+      result
+    end
+
+    private
+
+    def fetch_people_data
+      @fetch_people_data ||= begin
+        connection = Faraday.new
+        response = connection.get(API_URL, email: email, api_key: key)
+        
+        return {} unless response.success?
+
+        JSON.parse(response.body, symbolize_names: true)
+      end
+    end
+
+    def convert_hash_to_struct(struct, hash)
+      hash.each do |key, value|
+        if value.is_a?(Hash)
+          struct[key] = OpenStruct.new(value)
+          convert_hash_to_struct(struct[key], value)
+        elsif value.is_a?(Array) && value.first.is_a?(Hash)
+          struct[key] = value.map { |item| OpenStruct.new(item) }
+        end
+      end
+    end
+  end
+end

data/lib/email_hunter/search.rb

@@ -3,11 +3,11 @@
 require 'faraday'
 require 'json'
 
-API_SEARCH_URL = 'https://api.hunter.io/v2/domain-search?'
-
 module EmailHunter
   class Search
-    attr_reader :meta, :webmail, :emails, :pattern, :domain, :params, :key
+    API_URL = 'https://api.hunter.io/v2/domain-search'
+    
+    attr_reader :domain, :key, :params
 
     def initialize(domain, key, params = {})
       @domain = domain
@@ -16,24 +16,38 @@ module EmailHunter
     end
 
     def hunt
-      Struct.new(*data.keys).new(*data.values)
+      response_data = fetch_search_data
+      return nil if response_data.empty?
+      
+      Struct.new(*response_data.keys).new(*response_data.values)
     end
 
+    private
+
     def limit
-      params[:limit] || 10
+      params.fetch(:limit, 10).to_i
     end
 
     def offset
-      params[:offset] || 0
+      params.fetch(:offset, 0).to_i
     end
 
-    def data
-      @data ||= begin
-        response = Faraday.new("#{API_SEARCH_URL}domain=#{domain}&api_key=#{key}&type=#{params[:type]}&offset=#{offset}&limit=#{limit}").get
-
+    def fetch_search_data
+      @fetch_search_data ||= begin
+        connection = Faraday.new
+        request_params = {
+          domain: domain,
+          api_key: key,
+          offset: offset,
+          limit: limit
+        }
+        
+        request_params[:type] = params[:type] if params[:type]
+        response = connection.get(API_URL, request_params)
+        
         return {} unless response.success?
 
-        JSON.parse(response.body, { symbolize_names: true })
+        JSON.parse(response.body, symbolize_names: true)
       end
     end
   end

data/lib/email_hunter/verify.rb

@@ -3,12 +3,11 @@
 require 'faraday'
 require 'json'
 
-API_VERIFY_URL = 'https://api.hunter.io/v2/email-verifier?'
-
 module EmailHunter
   class Verify
-    attr_reader :result, :score, :regexp, :gibberish, :disposable, :webmail, :mx_records, :smtp_server, :smtp_check,
-                :accept_all, :sources, :meta, :key, :email
+    API_URL = 'https://api.hunter.io/v2/email-verifier'
+    
+    attr_reader :email, :key
 
     def initialize(email, key)
       @email = email
@@ -16,16 +15,22 @@ module EmailHunter
     end
 
     def hunt
-      Struct.new(*data.keys).new(*data.values)
+      response_data = fetch_verify_data
+      return nil if response_data.empty?
+      
+      Struct.new(*response_data.keys).new(*response_data.values)
     end
 
-    def data
-      @data ||= begin
-        response = Faraday.new("#{API_VERIFY_URL}email=#{email}&api_key=#{key}").get
+    private
 
-        return [] unless response.success?
+    def fetch_verify_data
+      @fetch_verify_data ||= begin
+        connection = Faraday.new
+        response = connection.get(API_URL, email: email, api_key: key)
+        
+        return {} unless response.success?
 
-        JSON.parse(response.body, { symbolize_names: true })
+        JSON.parse(response.body, symbolize_names: true)
       end
     end
   end

data/lib/email_hunter/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module EmailHunter
-  VERSION = '1.0.0'
+  VERSION = '1.1.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: emailhunter
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors:
 - Davide Santangelo
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-08-24 00:00:00.000000000 Z
+date: 2025-02-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -108,8 +108,10 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: 'A tiny ruby wrapper around Hunter.io API. Hunter.io helps sales people
-  reach their targets and increase their sales. '
+description: |
+  EmailHunter is a minimalistic Ruby wrapper for the Hunter.io API.
+  It provides a straightforward interface to integrate Hunter.io's
+  email discovery capabilities into your sales and marketing workflows.
 email:
 - davide.santangelo@gmail.com
 executables: []
@@ -130,17 +132,20 @@ files:
 - lib/email_hunter.rb
 - lib/email_hunter/account.rb
 - lib/email_hunter/api.rb
+- lib/email_hunter/company.rb
 - lib/email_hunter/count.rb
 - lib/email_hunter/exist.rb
 - lib/email_hunter/finder.rb
+- lib/email_hunter/people.rb
 - lib/email_hunter/search.rb
 - lib/email_hunter/verify.rb
 - lib/email_hunter/version.rb
 - lib/emailhunter.rb
-homepage:
+homepage: https://github.com/davidesantangelo/emailhunter
 licenses:
 - MIT
-metadata: {}
+metadata:
+  source_code_uri: https://github.com/davidesantangelo/emailhunter
 post_install_message:
 rdoc_options: []
 require_paths:
@@ -149,15 +154,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 1.9.3
+      version: 3.0.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.3
+rubygems_version: 3.3.26
 signing_key:
 specification_version: 4
-summary: A tiny ruby wrapper around Hunter.io API
+summary: A tiny Ruby wrapper around the Hunter.io API
 test_files: []