webmole 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: df9c01135d0b83dafa566f883f43f35defcc819873709a8da2a176b149444451
+  data.tar.gz: 11c6c44c605c0d740bc4ebc244b6e34acd56f637f80fbde72b177133df7fee6f
+SHA512:
+  metadata.gz: 7203dd2fc644fe3cee8a6c4c6c31bcb100596e157ad5ab274d6774d42a36779c263b371e7016c1a532d557f13edc5df73aaa72905fc751f4633868b245be1919
+  data.tar.gz: 60d83b4f4e70d4da6d2f7c086f90b15696a0ad97042e34a97a0528c02f3eac9883ca32d6b4ffa8f334451eefd39eae006675465a0b72e191640af5326b21e2d4

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2024 Subnetmasked
+
+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,49 @@
+# WebMole
+
+WebMole is a powerful web scraping tool built in Ruby. It allows you to crawl websites and extract various types of information such as emails, phone numbers, URLs, social media handles, addresses, and more.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'webmole'
+```
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install webmole
+
+## Usage
+
+To use WebMole, run the following command:
+
+```
+webmole -u https://example.com -s emails -d 2
+```
+
+This will crawl https://example.com to a depth of 2 and extract all email addresses found.
+
+For more options, run:
+
+```
+webmole --help
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`.
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/yourusername/webmole.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/bin/webmole

@@ -0,0 +1,82 @@
+#!/usr/bin/env ruby
+
+require 'optparse'
+require 'webmole'
+
+options = {}
+OptionParser.new do |opts|
+  opts.banner = "Usage: webmole [options]"
+
+  opts.on("-v", "--version", "Show version") do
+    puts "WebMole version #{WebMole::VERSION}"
+    exit
+  end
+
+  opts.on("-d", "--depth DEPTH", Integer, "Crawl depth (default: 3)") do |d|
+    options[:depth] = d
+  end
+
+  opts.on("-u", "--url URL", "Starting URL to crawl") do |url|
+    options[:url] = url
+  end
+
+  opts.on("-h", "--help", "Show this help message") do
+    puts opts
+    exit
+  end
+
+  opts.on("--delay SECONDS", Float, "Delay between requests in seconds (default: 1.0)") do |delay|
+    options[:delay] = delay
+  end
+
+  opts.on("-o", "--output FILE", "Output file") do |file|
+    options[:output] = file
+  end
+
+  opts.on("-f", "--format FORMAT", "Output format (txt, yaml, or csv)") do |format|
+    options[:format] = format.downcase
+  end
+
+  opts.on("-t", "--threads NUM", Integer, "Number of threads to use (default: 1)") do |t|
+    options[:threads] = t
+  end
+
+  opts.on("-s", "--scrape OPTION", "Scrape option (emails, phone_numbers, urls, social_media, addresses, credit_cards, custom)") do |option|
+    options[:scrape_option] = option.to_sym
+  end
+
+  opts.on("-p", "--pattern REGEX", "Custom regex pattern to search for (use with -s custom)") do |pattern|
+    options[:pattern] = pattern
+  end
+
+  opts.on("--verbose", "Enable verbose output") do
+    options[:verbose] = true
+  end
+
+  opts.on("--restrict-domain", "Restrict crawling to the initial domain") do
+    options[:restrict_domain] = true
+  end
+
+  opts.on("--timeout SECONDS", Integer, "Set a timeout for the crawl (default: 300 seconds)") do |t|
+    options[:timeout] = t
+  end
+
+  opts.on("--save-source-url", "Save the source URL for each match") do
+    options[:save_source_url] = true
+  end
+
+  opts.on("-g", "--gathering", "Enable gathering mode") do
+    options[:gathering_mode] = true
+  end
+end.parse!
+
+WebMole.print_banner
+WebMole.print_disclaimer
+
+begin
+  puts "\nPress Enter to continue or Ctrl+C to exit.".colorize(:yellow)
+  gets
+  WebMole.run(options)
+rescue Interrupt
+  puts "\nScript terminated by user.".colorize(:red)
+end

data/lib/webmole/crawler.rb

@@ -0,0 +1,161 @@
+require_relative 'scraper'
+require_relative 'output_formatter'
+require_relative 'user_agent_switcher'
+require_relative 'gathering_mode'
+require 'open-uri'
+
+module WebMole
+  class Crawler
+    def initialize(options)
+      @url = options[:url]
+      @depth = options[:depth] || 3
+      @delay = options[:delay] || 1.0
+      @threads = options[:threads] || 1
+      @verbose = options[:verbose]
+      @restrict_domain = options[:restrict_domain]
+      @initial_domain = URI(@url).host
+      @timeout = options[:timeout] || 300
+      @urls_to_scrape = Set.new
+      @visited = Set.new
+      @mutex = Mutex.new
+      @output = options[:output]
+      @format = options[:format]
+      @save_source_url = options[:save_source_url]
+      @user_agent_switcher = UserAgentSwitcher.new
+      @gathering_mode = options[:gathering_mode]
+      @scraper = Scraper.new(options[:scrape_option], options[:pattern], @gathering_mode)
+      GatheringMode.setup if @gathering_mode
+    end
+
+    def crawl
+      start_time = Time.now
+
+      puts "Phase 1: Discovering URLs to scrape...".colorize(:cyan)
+      discover_urls
+
+      puts "\nPhase 2: Scraping discovered URLs...".colorize(:cyan)
+      process_urls
+
+      end_time = Time.now
+      print_summary(start_time, end_time)
+    end
+
+    private
+
+    def discover_urls
+      queue = Queue.new
+      queue.push([@url, @depth])
+      @visited.add(@url)
+
+      thread_count = [@threads, 1].max  # Ensure at least 1 thread
+      discovery_threads = thread_count.times.map do
+        Thread.new do
+          while !queue.empty?
+            url, depth = queue.pop(true) rescue nil
+            break unless url && depth
+            discover_links(url, depth, queue)
+          end
+        end
+      end
+
+      discovery_threads.each(&:join)
+      puts "Discovered #{@urls_to_scrape.size} URLs to scrape.".colorize(:green)
+    end
+
+    def discover_links(url, depth, queue)
+      return if depth < 0
+
+      puts "Discovering: #{url}".colorize(:light_blue) if @verbose
+
+      begin
+        doc = fetch_page(url)
+        find_links(doc, url).each do |link|
+          next if @restrict_domain && URI(link).host != @initial_domain
+          if @visited.add?(link)
+            @urls_to_scrape.add(link)
+            queue.push([link, depth - 1])
+          end
+        end
+      rescue StandardError => e
+        puts "Error discovering links from #{url}: #{e.message}".colorize(:red) if @verbose
+      ensure
+        sleep(@delay)
+      end
+    end
+
+    def find_links(doc, base_url)
+      base_uri = URI(base_url)
+      doc.css('a').map { |link| link['href'] }.compact.map do |href|
+        begin
+          uri = URI(href)
+          if uri.scheme.nil?
+            URI.join(base_uri, href).to_s
+          elsif ['http', 'https'].include?(uri.scheme.downcase)
+            uri.to_s
+          else
+            nil
+          end
+        rescue URI::InvalidURIError, NoMethodError
+          nil
+        end
+      end.compact
+    end
+
+    def process_urls
+      total_urls = @urls_to_scrape.size
+      processed = 0
+      start_time = Time.now
+
+      @urls_to_scrape.each do |url|
+        crawl_url(url)
+        processed += 1
+        
+        elapsed_time = Time.now - start_time
+        avg_time_per_url = elapsed_time / processed
+        estimated_time_left = avg_time_per_url * (total_urls - processed)
+        
+        puts "Processed: #{processed}/#{total_urls} | " \
+             "Elapsed: #{format_time(elapsed_time)} | " \
+             "Est. Left: #{format_time(estimated_time_left)}".colorize(:cyan)
+      end
+    end
+
+    def crawl_url(url)
+      puts "Crawling: #{url}".colorize(:light_blue)
+
+      begin
+        doc = fetch_page(url)
+        @scraper.scrape(doc.text, url)
+      rescue OpenURI::HTTPError => e
+        puts "HTTP Error crawling #{url}: #{e.message}".colorize(:red)
+      rescue SocketError, URI::InvalidURIError => e
+        puts "Error crawling #{url}: #{e.message}".colorize(:red)
+      rescue StandardError => e
+        puts "Unexpected error crawling #{url}: #{e.message}".colorize(:red)
+      ensure
+        sleep(@delay)
+      end
+    end
+
+    def fetch_page(url)
+      user_agent = @user_agent_switcher.random_user_agent
+      Nokogiri::HTML(URI.open(url, 'User-Agent' => user_agent))
+    end
+
+    def format_time(seconds)
+      minutes, seconds = seconds.divmod(60)
+      hours, minutes = minutes.divmod(60)
+      [hours, minutes, seconds].map { |t| t.to_i.to_s.rjust(2, '0') }.join(':')
+    end
+
+    def print_summary(start_time, end_time)
+      puts "\nCrawling complete!".colorize(:green)
+      puts "Total URLs processed: #{@urls_to_scrape.size}".colorize(:cyan)
+      puts "Total matches found: #{@scraper.matches.size}".colorize(:cyan)
+      puts "Total time: #{format_time(end_time - start_time)}".colorize(:cyan)
+
+      OutputFormatter.new(@format, @output, @save_source_url).format_results(@scraper.matches)
+      GatheringMode.print_summary if @gathering_mode
+    end
+  end
+end

data/lib/webmole/gathering_mode.rb

@@ -0,0 +1,45 @@
+require 'fileutils'
+require 'set'
+
+module WebMole
+  class GatheringMode
+    @gathering_dir = File.join(Dir.home, '.webmole_gathered')
+    @gathered_data = Hash.new { |h, k| h[k] = Set.new }
+
+    class << self
+      def setup
+        FileUtils.mkdir_p(@gathering_dir) unless File.directory?(@gathering_dir)
+        load_existing_data
+      end
+
+      def save_to_gathering(match, type)
+        @gathered_data[type].add(match)
+        save_data(type)
+      end
+
+      def print_summary
+        puts "\nGathering mode summary:".colorize(:green)
+        @gathered_data.each do |type, matches|
+          puts "#{type}: #{matches.size} unique entries".colorize(:cyan)
+        end
+      end
+
+      private
+
+      def load_existing_data
+        Dir.glob(File.join(@gathering_dir, 'gathered_*.txt')).each do |file|
+          type = File.basename(file, '.txt').sub('gathered_', '')
+          File.readlines(file, chomp: true).each do |line|
+            @gathered_data[type].add(line)
+          end
+        end
+      end
+
+      def save_data(type)
+        File.open(File.join(@gathering_dir, "gathered_#{type}.txt"), 'w') do |f|
+          @gathered_data[type].each { |match| f.puts match }
+        end
+      end
+    end
+  end
+end

data/lib/webmole/output_formatter.rb

@@ -0,0 +1,84 @@
+require 'yaml'
+require 'csv'
+
+module WebMole
+  class OutputFormatter
+    def initialize(format = nil, output = nil, save_source_url = false)
+      @format = format
+      @output = output
+      @save_source_url = save_source_url
+    end
+
+    def format_results(matches)
+      if @output
+        save_results(matches)
+      else
+        print_results(matches)
+      end
+    end
+
+    private
+
+    def print_results(matches)
+      puts "Found matches:".colorize(:green)
+      matches.each do |match, urls|
+        if @save_source_url
+          urls.each { |url| puts "#{match} - #{url}".colorize(:cyan) }
+        else
+          puts match.colorize(:cyan)
+        end
+      end
+      puts "Total matches found: #{matches.size}".colorize(:yellow)
+    end
+
+    def save_results(matches)
+      case @format
+      when 'txt'
+        save_as_txt(matches)
+      when 'yaml'
+        save_as_yaml(matches)
+      when 'csv'
+        save_as_csv(matches)
+      else
+        puts "Unsupported format: #{@format}".colorize(:red)
+      end
+      puts "Total matches found: #{matches.size}".colorize(:yellow)
+    end
+
+    def save_as_txt(matches)
+      File.open(@output, 'w') do |file|
+        file.puts "Found matches:"
+        matches.each do |match, urls|
+          if @save_source_url
+            urls.each { |url| file.puts "#{match} - #{url}" }
+          else
+            file.puts match
+          end
+        end
+      end
+      puts "Results saved to #{@output}".colorize(:green)
+    end
+
+    def save_as_yaml(matches)
+      File.open(@output, 'w') do |file|
+        data = @save_source_url ? matches : matches.keys
+        file.write({ matches: data }.to_yaml)
+      end
+      puts "Results saved to #{@output}".colorize(:green)
+    end
+
+    def save_as_csv(matches)
+      CSV.open(@output, 'w') do |csv|
+        csv << (@save_source_url ? ['Match', 'Source URL'] : ['Match'])
+        matches.each do |match, urls|
+          if @save_source_url
+            urls.each { |url| csv << [match, url] }
+          else
+            csv << [match]
+          end
+        end
+      end
+      puts "Results saved to #{@output}".colorize(:green)
+    end
+  end
+end

data/lib/webmole/scraper.rb

@@ -0,0 +1,77 @@
+require_relative 'gathering_mode'
+
+module WebMole
+  class Scraper
+    attr_reader :matches
+
+    def initialize(scrape_option, pattern, gathering_mode = false)
+      @scrape_option = scrape_option
+      @pattern = pattern ? Regexp.new(pattern) : nil
+      @matches = Hash.new { |h, k| h[k] = Set.new }
+      @gathering_mode = gathering_mode
+    end
+
+    def scrape(text, url)
+      case @scrape_option
+      when :emails
+        find_emails(text, url)
+      when :phone_numbers
+        find_phone_numbers(text, url)
+      when :urls
+        find_urls(text, url)
+      when :social_media
+        find_social_media(text, url)
+      when :addresses
+        find_addresses(text, url)
+      when :credit_cards
+        find_credit_cards(text, url)
+      when :custom
+        find_matches(text, url)
+      end
+    end
+
+    private
+
+    def find_emails(text, url)
+      matches = text.scan(/\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b/)
+      add_matches(matches, url, 'emails')
+    end
+
+    def find_phone_numbers(text, url)
+      matches = text.scan(/\b\d{3}[-.]?\d{3}[-.]?\d{4}\b/)
+      add_matches(matches, url, 'phone_numbers')
+    end
+
+    def find_urls(text, url)
+      matches = text.scan(/https?:\/\/[\S]+/)
+      add_matches(matches, url, 'urls')
+    end
+
+    def find_social_media(text, url)
+      matches = text.scan(/@[\w]+/)
+      add_matches(matches, url, 'social_media')
+    end
+
+    def find_addresses(text, url)
+      matches = text.scan(/\d+\s+([^\d\n]+\s)+(St|Ave|Rd|Blvd|Dr|Lane|Way)\.?/i)
+      add_matches(matches.map(&:join), url, 'addresses')
+    end
+
+    def find_credit_cards(text, url)
+      matches = text.scan(/\b(?:\d{4}[-\s]?){3}\d{4}\b/)
+      add_matches(matches, url, 'credit_cards')
+    end
+
+    def find_matches(text, url)
+      matches = text.scan(@pattern)
+      add_matches(matches, url, 'custom')
+    end
+
+    def add_matches(matches, url, type)
+      matches.each do |match|
+        @matches[match].add(url)
+        GatheringMode.save_to_gathering(match, type) if @gathering_mode
+      end
+    end
+  end
+end

data/lib/webmole/user_agent_switcher.rb

@@ -0,0 +1,41 @@
+require 'yaml'
+require 'fileutils'
+
+module WebMole
+  class UserAgentSwitcher
+    CONFIG_DIR = File.join(Dir.home, '.config', 'webmole')
+    CONFIG_FILE = File.join(CONFIG_DIR, 'user_agents.yml')
+
+    def initialize
+      ensure_config_file_exists
+      @user_agents = YAML.load_file(CONFIG_FILE)
+    rescue StandardError => e
+      puts "Warning: Error loading user_agents.yml: #{e.message}. Using default user agent.".colorize(:yellow)
+      @user_agents = ['Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36']
+    end
+
+    def random_user_agent
+      @user_agents.sample
+    end
+
+    private
+
+    def ensure_config_file_exists
+      return if File.exist?(CONFIG_FILE)
+
+      FileUtils.mkdir_p(CONFIG_DIR)
+      File.write(CONFIG_FILE, default_user_agents.to_yaml)
+      puts "Created default user_agents.yml in #{CONFIG_FILE}".colorize(:green)
+    end
+
+    def default_user_agents
+      [
+        'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36',
+        'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/14.1.1 Safari/605.1.15',
+        'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:89.0) Gecko/20100101 Firefox/89.0',
+        'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.114 Safari/537.36',
+        'Mozilla/5.0 (iPhone; CPU iPhone OS 14_6 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/14.1.1 Mobile/15E148 Safari/604.1'
+      ]
+    end
+  end
+end

data/lib/webmole/version.rb

@@ -0,0 +1,3 @@
+module WebMole
+  VERSION = '1.0.0'
+end

data/lib/webmole.rb

@@ -0,0 +1,51 @@
+require 'nokogiri'
+require 'open-uri'
+require 'uri'
+require 'set'
+require 'yaml'
+require 'csv'
+require 'colorize'
+
+require_relative 'webmole/version'
+require_relative 'webmole/crawler'
+require_relative 'webmole/scraper'
+require_relative 'webmole/output_formatter'
+require_relative 'webmole/user_agent_switcher'
+require_relative 'webmole/gathering_mode'
+
+module WebMole
+  class Error < StandardError; end
+
+  def self.run(options)
+    crawler = Crawler.new(options)
+    crawler.crawl
+  end
+
+  def self.print_banner
+    puts <<-'EOB'.colorize(:light_blue)
+__        __   _     __  __       _      
+\ \      / /__| |__ |  \/  | ___ | | ___ 
+ \ \ /\ / / _ \ '_ \| |\/| |/ _ \| |/ _ \
+  \ V  V /  __/ |_) | |  | | (_) | |  __/
+   \_/\_/ \___|_.__/|_|  |_|\___/|_|\___|
+                                         
+    EOB
+    puts "WebMole v#{VERSION}".colorize(:light_cyan)
+    puts "A relatively powerful web scraper.".colorize(:light_green)
+    puts
+  end
+
+  def self.print_disclaimer
+    puts "DISCLAIMER:".colorize(:yellow)
+    puts <<-EOD.colorize(:light_yellow)
+This tool is for educational and ethical use only. The user bears all responsibility
+for ensuring compliance with applicable laws, regulations, and website terms of service.
+Misuse of this tool may be illegal and/or unethical. Always obtain proper authorization
+before scraping any website.
+
+Contact: Subnetmasked <subnetmasked@cock.li>
+
+By using this tool, you agree to these terms and conditions.
+    EOD
+  end
+end

data/webmole.gemspec

@@ -0,0 +1,30 @@
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'webmole/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "webmole"
+  spec.version       = WebMole::VERSION
+  spec.authors       = ["Subnetmasked"]
+  spec.email         = ["subnetmasked@cock.li"]
+  spec.summary       = %q{A powerful web scraper}
+  spec.description   = %q{WebMole is a Ruby-based web scraper with multiple features including email extraction, phone number scraping, and more.}
+  spec.homepage      = "https://github.com/subnetmasked/webmole"
+  spec.license       = "MIT"
+  spec.required_ruby_version = '>= 3.0'
+  
+  spec.files = Dir['lib/**/*', 'bin/*', 'LICENSE.txt', '*.md', 'webmole.gemspec']
+  spec.bindir        = "bin"
+  spec.executables   = ["webmole"]
+  spec.require_paths = ["lib"]
+  
+  spec.add_dependency "nokogiri", "~> 1.11"
+  spec.add_dependency "colorize", "~> 0.8"
+  spec.add_dependency "optparse", "~> 0.5.0"
+  spec.add_dependency "uri", "~> 0.13.1"
+  spec.add_dependency "csv", "~> 3.2"
+  
+  spec.add_development_dependency "bundler", "~> 2.0"
+  spec.add_development_dependency "rake", "~> 13.0"
+  spec.add_development_dependency "rspec", "~> 3.10"
+end

metadata

@@ -0,0 +1,168 @@
+--- !ruby/object:Gem::Specification
+name: webmole
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Subnetmasked
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2024-10-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+- !ruby/object:Gem::Dependency
+  name: colorize
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+- !ruby/object:Gem::Dependency
+  name: optparse
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.5.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.5.0
+- !ruby/object:Gem::Dependency
+  name: uri
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.13.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.13.1
+- !ruby/object:Gem::Dependency
+  name: csv
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.10'
+description: WebMole is a Ruby-based web scraper with multiple features including
+  email extraction, phone number scraping, and more.
+email:
+- subnetmasked@cock.li
+executables:
+- webmole
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- bin/webmole
+- lib/webmole.rb
+- lib/webmole/crawler.rb
+- lib/webmole/gathering_mode.rb
+- lib/webmole/output_formatter.rb
+- lib/webmole/scraper.rb
+- lib/webmole/user_agent_switcher.rb
+- lib/webmole/version.rb
+- webmole.gemspec
+homepage: https://github.com/subnetmasked/webmole
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.21
+signing_key:
+specification_version: 4
+summary: A powerful web scraper
+test_files: []