dns-sniper 0.0.1.pre3 → 0.0.1.pre8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: eb0e330d2e7c2b4061f4c93ff5825ff09d768a55f57e732e6557f13e822c9436
-  data.tar.gz: 6909002d1f80141a9855b917be54c0e2076c0b465f2f8aa6cf143ea93f6eba8d
+  metadata.gz: 512e7b14734237f57edc560759f751a748083c2639fa4adc5beac81f460222f5
+  data.tar.gz: f1223fae9ec10a2b42c797dd43a1a874ac916f241272cb84526994994c82d621
 SHA512:
-  metadata.gz: bbb70cdbbf01ade47a2d6b359fe63fb97e1c577795d979746d93c858b0644313e0285415acf86a79d56a6baaaa6c0cc1b908bc01fb90b8b90d6bb86df2219125
-  data.tar.gz: f5773fc187a174a969c4c8953ab3c24e9803a3eba481fb028f300a9886aa09391d85a9f5383c46a726d123b954489f4e6e5a1a613b6300f4cdbdae3ddb353bc2
+  metadata.gz: 93631146a7ae4eedf7fbe3d4275f5156a3cac90eb665f4c916c5b6e37977d23b91716bccae8074c8b5492fa0cc21607ebeafe246d9879f89627710c4bbff24d3
+  data.tar.gz: e7b9d0fc865c070561129f21aea1a936b21f5d357affeb8cc096946922059977640aea8d323035ddcc39737a31bef2d18d35d2aaa832fb90771fdcd3944b874e

data/Gemfile.lock

@@ -1,26 +1,25 @@
 PATH
   remote: .
   specs:
-    sniper (0.0.1)
+    dns-sniper (0.0.1.pre6)
+      down (~> 5.1)
+      hosts_file (~> 1.0)
 
 GEM
   remote: https://rubygems.org/
   specs:
     addressable (2.7.0)
       public_suffix (>= 2.0.2, < 5.0)
-    down (5.1.1)
+    down (5.2.2)
       addressable (~> 2.5)
     hosts_file (1.0.3)
-    public_suffix (4.0.5)
+    public_suffix (4.0.6)
 
 PLATFORMS
   ruby
 
 DEPENDENCIES
-  bundler (~> 2.1.2)
-  down (~> 5.1)
-  hosts_file (~> 1.0)
-  sniper!
+  dns-sniper!
 
 BUNDLED WITH
    2.1.2

data/README.md

@@ -40,26 +40,19 @@ require 'dns-sniper'
 
 hostnames = DNSSniper::Hostnames.new
 
-# Block domain names
-hostnames.add_from('https://pgl.yoyo.org/as/serverlist.php?hostformat=hosts;showintro=0;mimetype=plaintext') # From the web
-hostnames.add_from('https://raw.githubusercontent.com/brodyhoskins/dns-blocklists/master/tracking.list')
-hostnames.add_from('~/.config/dns-sniper/blocklists.list') # From filesystem
-
-# Manually add domain name
-hostnames.add('ads.yahoo.com')
-hostnames.add(['ads.doubleclick.net', 'ads.msn.com'])
-
-# Remove whitelisted domain names
-hostnames.remove_from('~/.config/dns-sniper/whitelisted-hostnames.list')
-hostnames.remove_from('https://example.com/whitelisted.hosts')
-
-# Manually remove domain name
-hostnames.remove('favoritewebsite.com')
-hostnames.remove(['favoritewebsite.com', 'otherfavoritewebsite.com'])
-
-# Convert to configuration file
-hostnames.to_format('dnsmasq')
-hostnames.to_format('unbound')
+# Manually add blacklisted or whitelisted domains
+hostnames.blacklist += 'ads.yahoo.com'
+hostnames.whitelist += 'favoritewebsite.com'
+
+# Use an Importer to process external lists
+hostnames.blacklist += DNSSniper::DomainsImporter.new('https://raw.githubusercontent.com/brodyhoskins/dns-blocklists/master/tracking.list').hostnames
+hostnames.blacklist += DNSSniper::HostsImporter.new('https://pgl.yoyo.org/as/serverlist.php?hostformat=hosts;showintro=0;mimetype=plaintext').hostnames
+
+# Blocklist is accessible as an Array
+hostnames.blocklist
+
+# Use an Exporter to convert to other formats
+UnboundExporter.new(hostnames.blocklist).data
 ```
 
 ### From CLI
@@ -71,7 +64,6 @@ Using the CLI version makes it easy to update configuration formats automaticall
 ```bash
 #!/usr/bin/env bash
 
-/path/to/dns-sniper -f ~/.config/dns-sniper/blacklist.list -w ~/.config/dns-sniper/whitelist.list -o unbound > /etc/unbound/unbound.conf.t/blocklist.conf
-
+/path/to/dns-sniper --conf ~/.config/dns-sniper/dns-sniper.yml --output unbound > /etc/unbound/unbound.conf.d/blocklist.conf
 service unbound reload
 ```

data/bin/dns-sniper

@@ -5,19 +5,16 @@ require 'optparse'
 require 'set'
 require 'dns-sniper'
 
-VALID_FORMATS = DNSSniper::Formatters.all.inject([]) { |arr, f| arr << f.name.to_s.sub('DNSSniper::', '').downcase }
-Options = Struct.new(:blacklist_urls_file, :whitelisted_hosts_file, :format)
+VALID_FORMATS = DNSSniper::Exporters.all.inject([]) { |arr, f| arr << f.name.to_s.sub('DNSSniper::', '').sub('Exporter', '').downcase }
+Options = Struct.new(:conf_path, :format)
 
 class Parser
   def self.parse(options)
     args = Options.new('world')
     opt_parser = OptionParser.new do |opts|
       opts.banner = "Usage: #{File.basename(__FILE__)} -f PATH -o FORMAT [options]\n#{File.basename(__FILE__)} combines online DNS blacklists and combines them into the desired configuration FORMAT.\n\n"
-      opts.on('-f', '--blacklist=PATH', 'PATH to file with line-separated list of URL’s of blacklists') do |path|
-        args.blacklist_urls_file = path
-      end
-      opts.on('-w', '--whitelist=path', 'Path to file with line-separated list of whitelisted hostnames') do |path|
-        args.whitelisted_hosts_file = path
+      opts.on('-c', '--conf=PATH', 'PATH to YAML configuration file') do |path|
+        args.conf_path = path
       end
       opts.on('-o', '--output=FORMAT', "FORMAT to output — one of #{VALID_FORMATS.join(', ')}") do |format|
         args.format = format
@@ -34,20 +31,20 @@ end
 
 options = Parser.parse ARGV
 
-unless VALID_FORMATS.include?(options[:format])
-  warn options[:format].blank? ? 'Error: Format not defined' : "Error: Invalid format \"#{options[:format]}\""
+unless File.exist?(options[:conf_path])
+  warn "Error: Unable to access ”#{options[:conf_path]}”"
   exit(-1)
 end
 
-unless File.exist?(options[:blacklist_urls_file])
-  warn "Error: Unable to access ”#{options[:blacklist_urls_file]}”"
-  exit(-1)
-end
-
-if options[:whitelisted_hosts_file] && !File.exist?(options[:whitelisted_hosts_file])
-  warn "Error: Unable to access ”#{options[:whitelisted_hosts_file]}”"
+exporter = DNSSniper.const_get("#{options[:format].to_s.split('_').map(&:capitalize).join}Exporter")
+if !exporter
+  warn "Error: Invalid format #{options[:format]}"
   exit(-1)
 end
 
 hostnames = DNSSniper::Hostnames.new
-puts hostnames.add_from(File.open(options[:blacklist_urls_file]).readlines).remove_from(options[:whitelisted_hosts_file]).to_format(options[:format])
+hostnames.blacklist += DNSSniper::ConfigurationImporter.new(options[:conf_path], list: :reject).hostnames
+hostnames.whitelist += DNSSniper::ConfigurationImporter.new(options[:conf_path], list: :allow).hostnames
+
+exporter = exporter.new(hostnames.blocklist)
+puts exporter.data

data/config.yml.example

@@ -0,0 +1,9 @@
+:sources:
+  :allow:
+    - :importer: :domains
+      :uri: https://example.com/whitelisted.domains.list
+  :reject:
+    - :importer: :domains
+      :uri: https://raw.githubusercontent.com/brodyhoskins/dns-blocklists/master/tracking.list
+    - :importer: :hosts
+      :uri: https://pgl.yoyo.org/as/serverlist.php?hostformat=hosts;showintro=0;mimetype=plaintext

data/dns-sniper.gemspec

@@ -3,8 +3,8 @@
 Gem::Specification.new do |spec|
   spec.name = 'dns-sniper'
   spec.license = 'MIT'
-  spec.version = '0.0.1.pre3'
-  spec.date = '2020-11-01'
+  spec.version = '0.0.1.pre8'
+  spec.date = '2021-06-28'
 
   spec.authors = ['Brody Hoskins']
   spec.email = ['brody@brody.digital']

data/lib/dns-sniper.rb

@@ -1,5 +1,10 @@
 # frozen_string_literal: true
 
+require 'resolv'
+require 'yaml'
+
+require 'dns-sniper/exporter'
+require 'dns-sniper/exporters'
 require 'dns-sniper/hostnames'
-require 'dns-sniper/formatter'
-require 'dns-sniper/formatters'
+require 'dns-sniper/importer'
+require 'dns-sniper/importers'

data/lib/dns-sniper/{formatter.rb → exporter.rb}

@@ -1,13 +1,15 @@
 # frozen_string_literal: true
 
 module DNSSniper
-  class Formatter
+  class Exporter
+    attr_accessor :data, :hostnames
+
     def initialize(hostnames, options = {})
       @hostnames = hostnames
-      @options = options
+      @data = output(options)
     end
 
-    def output
+    def output(*)
       raise NotImplementedError, "Error: #output isn’t supported by #{self.class.name}"
     end
   end

data/lib/dns-sniper/exporters.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module DNSSniper
+  module Exporters
+    module_function
+
+    attr_reader :registered
+    @registered = []
+
+    def register(class_name, autoload_require)
+      DNSSniper.autoload(class_name, autoload_require)
+      @registered << class_name
+    end
+
+    def all
+      @registered.map { |name| DNSSniper.const_get(name) }
+    end
+
+    def find(name)
+      all.find { |c| c.name.downcase == name.to_s.downcase } or raise NameError, "Unknown exporter \"#{name}\""
+    end
+  end
+end
+
+DNSSniper::Exporters.register :Bind8Exporter, 'dns-sniper/exporters/bind8_exporter'
+DNSSniper::Exporters.register :DnsmasqExporter, 'dns-sniper/exporters/dnsmasq_exporter'
+DNSSniper::Exporters.register :HostsExporter, 'dns-sniper/exporters/hosts_exporter'
+DNSSniper::Exporters.register :NetgearExporter, 'dns-sniper/exporters/netgear_exporter'
+DNSSniper::Exporters.register :TextExporter, 'dns-sniper/exporters/text_exporter'
+DNSSniper::Exporters.register :UnboundExporter, 'dns-sniper/exporters/unbound_exporter'

data/lib/dns-sniper/{formatters/bind8.rb → exporters/bind8_exporter.rb}

@@ -1,12 +1,7 @@
 # frozen_string_literal: true
 
 module DNSSniper
-  class Bind8 < Formatter
-    def initialize(hostnames, options = {})
-      @hostnames = hostnames
-      @options = options
-    end
-
+  class Bind8Exporter < Exporter
     def output(options = {})
       raise ArgumentError, 'zone_file is required' unless defined?(options[:zone_file])
 

data/lib/dns-sniper/{formatters/dnsmasq.rb → exporters/dnsmasq_exporter.rb}

@@ -1,13 +1,8 @@
 # frozen_string_literal: true
 
 module DNSSniper
-  class Dnsmasq < Formatter
-    def initialize(hostnames, options = {})
-      @hostnames = hostnames
-      @options = options
-    end
-
-    def output(_options = {})
+  class DnsmasqExporter < Exporter
+    def output(*)
       str = ''.dup
       @hostnames.each do |hostname|
         str << "server=/#{hostname}/#{$/}"

data/lib/dns-sniper/{formatters/hosts.rb → exporters/hosts_exporter.rb}

@@ -1,13 +1,8 @@
 # frozen_string_literal: true
 
 module DNSSniper
-  class Hosts < Formatter
-    def initialize(hostnames, options = {})
-      @hostnames = hostnames
-      @options = options
-    end
-
-    def output(_options = {})
+  class HostsExporter < Exporter
+    def output(*)
       str = ''.dup
       @hostnames.each do |hostname|
         str << "127.0.0.1\t#{hostname}#{$/}"

data/lib/dns-sniper/{formatters/netgear.rb → exporters/netgear_exporter.rb}

@@ -1,13 +1,8 @@
 # frozen_string_literal: true
 
 module DNSSniper
-  class Netgear < Formatter
-    def initialize(hostnames, options = {})
-      @hostnames = hostnames
-      @options = options
-    end
-
-    def output(_options = {})
+  class NetgearExporter < Exporter
+    def output(*)
       str = ''.dup
       @hostnames.each_with_index do |hostname, i|
         str << "[517003_e]: #{i + 1}) #{hostname}\n"

data/lib/dns-sniper/exporters/text_exporter.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module DNSSniper
+  class TextExporter < Exporter
+    def output(_options = {})
+      @hostnames.to_a.join($/)
+    end
+  end
+end

data/lib/dns-sniper/{formatters/unbound.rb → exporters/unbound_exporter.rb}

@@ -1,13 +1,8 @@
 # frozen_string_literal: true
 
 module DNSSniper
-  class Unbound < Formatter
-    def initialize(hostnames, options = {})
-      @hostnames = hostnames
-      @options = options
-    end
-
-    def output(_options = {})
+  class UnboundExporter < Exporter
+    def output(*)
       str = ''.dup
       str << "server:#{$/}"
       @hostnames.each do |hostname|

data/lib/dns-sniper/hostnames.rb

@@ -7,151 +7,28 @@ require 'resolv'
 
 module DNSSniper
   class Hostnames
-    def initialize(_options = {})
-      @hostnames = [].to_set
-      self
-    end
-
-    def add(hostnames)
-      hostnames = clean(hostnames.class == String ? [hostnames] : hostnames)
-      @hostnames += hostnames unless hostnames.empty?
-      self
-    end
-
-    def add_from(paths_or_urls)
-      return self unless paths_or_urls
-
-      paths_or_urls = [paths_or_urls] if paths_or_urls.class == String
-
-      paths_or_urls.each do |path_or_url|
-        path_or_url = path_or_url.strip
-
-        if File.exist?(path_or_url)
-          contents = File.open(path_or_url).readlines
-        else
-          begin
-            down = Down.download(path_or_url)
-            path_or_url = down.path
-            contents = down.readlines
-          rescue Down::NotFound
-            warn "\"#{path_or_url}\" does not exist"
-            return self
-          rescue Down::ResponseError
-            warn "\"#{path_or_url}\": No data from server"
-            return self
-          end
-        end
-
-        case syntax(path_or_url, contents)
-        when nil
-          warn "Error: Syntax: Syntax of \"#{path_or_url}\" not recognized, ignored"
-          return self
-        when 'hosts'
-          add from_hosts_file(path_or_url)
-        when 'hostnames'
-          add from_hostnames_file(contents)
-        end
-      end
-
-      self
-    end
-
-    def remove(hostnames)
-      hostnames = clean(hostnames.class == String ? [hostnames] : hostnames)
-      @hostnames -= hostnames unless hostnames.empty?
-      self
-    end
-
-    def remove_from(paths_or_urls)
-      return self unless paths_or_urls
-
-      paths_or_urls = [paths_or_urls] if paths_or_urls.class == String
-
-      paths_or_urls.each do |path_or_url|
-        path_or_url = path_or_url.strip
-
-        if File.exist?(path_or_url)
-          contents = File.open(path_or_url).readlines
-        else
-          begin
-            down = Down.download(path_or_url)
-            path_or_url = down.path
-            contents = down.readlines
-          rescue Down::NotFound
-            warn "\"#{path_or_url}\" does not exist"
-            return self
-          rescue Down::ResponseError
-            warn "\"#{path_or_url}\": No data from server"
-            return self
-          end
-        end
-
-        case syntax(path_or_url, contents)
-        when nil
-          warn "Error: Syntax: Syntax of \"#{path_or_url}\" not recognized, ignored"
-          return self
-        when 'hosts'
-          remove from_hosts_file(path_or_url)
-        when 'hostnames'
-          remove from_hostnames_file(contents)
-        end
-      end
+    attr_accessor :blacklist
+    attr_accessor :whitelist
 
+    def initialize
+      @blacklist = []
+      @whitelist = []
       self
     end
 
-    def to_format(format, options = {})
-      format = format.capitalize
-      begin
-        klass = DNSSniper.const_get(format)
-        klass.new(@hostnames.to_a).output(options)
-      rescue NameError
-        false
-      end
-    end
-
-    def to_a
-      @hostnames.to_a
-    end
-
-    private
+    def blocklist
+      blacklist = @blacklist
+      whitelist = @whitelist
 
-    def clean(hostnames)
-      cleaned_hostnames = []
-      hostnames.each do |hostname|
-        hostname = hostname.downcase.strip
-        hostname = hostname.sub('www.', '')
-        hostname_top_domain = "#{hostname.split('.')[-2]}.#{hostname.split('.')[-1]}"
-
-        if !hostname.include?('#') && !['broadcasthost', 'localhost', ''].include?(hostname) && !@hostnames.include?(hostname_top_domain)
-          cleaned_hostnames << hostname
-        end
-      end
-      cleaned_hostnames
-    end
-
-    def syntax(path_or_url, contents)
-      contents.each do |line|
-        next if line.include?('#')
-
-        line = line.downcase
-
-        if line.strip.split(/\s/).first =~ Regexp.union([Resolv::IPv4::Regex, Resolv::IPv6::Regex])
-          return 'hosts'
-        elsif line.include?('.') && (!line.include? 'http') && path_or_url.end_with?('.list')
-          return 'hostnames'
+      whitelist.each do |domain|
+        domain_parts = domain.split('.')
+        domain_parts.count.times do |count|
+          next if count == 1
+          whitelist += [domain_parts[count - 1, domain_parts.length].join('.')]
         end
       end
-      nil
-    end
-
-    def from_hosts_file(path_or_url)
-      # TODO: Remove downloading file twice
-      HostsFile.load(path_or_url).map(&:name)
-    end
 
-    def from_hostnames_file(contents)
-      contents.each { |line| add(line) }
+      blacklist - whitelist
     end
   end
 end

data/lib/dns-sniper/importer.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module DNSSniper
+  class Importer
+    attr_accessor :uri, :hostnames
+
+    def initialize(uri, *)
+      @uri = uri
+      @hostnames = File.exist?(uri) ? import_file(uri) : import_uri(uri)
+    end
+
+    def import_file(*)
+      raise NotImplementedError, "#{self.class.name}: #import_file not supported"
+    end
+
+    def import_uri(*)
+      raise NotImplementedError, "#{self.class.name}: #import_uri not supported"
+    end
+
+    # Helper methods
+
+    def clean(domain)
+      domain = domain.split('#')[0] if domain[0] != '#' && domain.include?('#')
+      domain = domain.split(':')[0] if domain.include?(':') && !ip_addr?(domain)
+      domain = domain.sub('www.', '') if domain.start_with?('www.') && domain.scan('www.').count == 1
+
+      domain.chomp.gsub(/\s+/, '').downcase
+    end
+
+    def rejector(domain)
+      !domain?(domain)
+    end
+
+    def domain?(domain)
+      return false if domain == ''
+      return false if domain.gsub('#', '').gsub(/\s+/, '').empty?
+      return false if domain[0] == '#'
+      return false if domain.include?(':')
+      return false if domain.include?('?')
+      return false if ip_addr?(domain)
+      return false unless /\b((?=[a-z0-9-]{1,63}\.)(xn--)?[a-z0-9]+(-[a-z0-9]+)*\.)+[a-z]{2,63}\b/.match?(domain)
+      return false unless /^[a-z0-9]+([\-\.]{1}[a-z0-9]+)*\.[a-z]{2,5}$/.match?(domain)
+
+      begin
+        return false if URI.parse(domain).is_a?(URI::HTTP)
+      rescue URI::InvalidURIError; end
+      true
+    end
+
+    def ip_addr?(domain)
+      domain =~ Regexp.union([Resolv::IPv4::Regex, Resolv::IPv6::Regex])
+    end
+  end
+end

data/lib/dns-sniper/importers.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module DNSSniper
+  module Importers
+    module_function
+
+    attr_reader :registered
+    @registered = []
+
+    def register(class_name, autoload_require)
+      DNSSniper.autoload(class_name, autoload_require)
+      @registered << class_name
+    end
+
+    def all
+      @registered.map { |name| DNSSniper.const_get(name) }
+    end
+
+    def find(name)
+      all.find { |c| c.name.downcase == name.to_s.downcase } or raise NameError, "Unknown Importer \"#{name}\""
+    end
+  end
+end
+
+DNSSniper::Importers.register :ConfigurationImporter, 'dns-sniper/importers/configuration_importer'
+DNSSniper::Importers.register :DomainsImporter, 'dns-sniper/importers/domains_importer'
+DNSSniper::Importers.register :HostsImporter, 'dns-sniper/importers/hosts_importer'

data/lib/dns-sniper/importers/configuration_importer.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module DNSSniper
+  class ConfigurationImporter < Importer
+    def initialize(uri, list:)
+      @uri = uri
+      @hostnames = File.exist?(uri) ? import_file(uri, list: list) : import_uri(uri, list: list)
+    end
+
+    def import_file(path, list:)
+      raise ArgumentError, "#{self.class.name}: #from_path requies list to be defined" unless list
+      return [] unless File.exist?(path)
+
+      yaml = YAML.safe_load(File.read(path), permitted_classes: [Symbol])
+      return [] unless yaml.dig(:sources)&.dig(list.to_sym)
+
+      hostnames = []
+      yaml.dig(:sources).dig(list.to_sym).each do |source|
+        return [] unless source.dig(:importer)
+        return [] unless source.dig(:uri)
+
+        importer = DNSSniper.const_get("#{source.dig(:importer).to_s.split('_').map(&:capitalize).join}Importer")
+        if !importer
+          next
+        else
+          importer = importer.new(source.dig(:uri))
+          hostnames += importer.hostnames
+        end
+      end
+
+      hostnames
+    end
+
+    def import_uri(_uri, list:)
+      raise NotImplementedError, "#{self.class.name}: #from_uri not supported"
+    end
+  end
+end

data/lib/dns-sniper/importers/domains_importer.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module DNSSniper
+  class DomainsImporter < Importer
+    def import_file(path)
+      return [] unless File.exist?(path)
+
+      File.open(path).readlines(chomp: true).map { |hostname| clean(hostname) }.reject { |hostname| rejector(hostname) }
+    end
+
+    def import_uri(uri)
+      begin
+        down = Down.download(uri)
+        return down.readlines(chomp: true).map { |hostname| clean(hostname) }.reject { |hostname| rejector(hostname) }
+      rescue Down::InvalidUrl => e
+        warn "#{self.class.name}: #{e}"
+      end
+
+      []
+    end
+  end
+end

data/lib/dns-sniper/importers/hosts_importer.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module DNSSniper
+  class HostsImporter < Importer
+    def import_file(path, *)
+      return [] unless File.exist?(path)
+
+      HostsFile.load(path).map(&:name).map { |hostname| clean(hostname) }.reject { |hostname| rejector(hostname) }
+    end
+
+    def import_uri(uri, *)
+      begin
+        down = Down.download(uri)
+        path = down.path
+      rescue Down::InvalidUrl => e
+        warn "#{self.class.name}: #{e}"
+      end
+
+      if path
+        return HostsFile.load(path).map(&:name).map { |hostname| clean(hostname) }.reject { |hostname| rejector(hostname) }
+      end
+
+      []
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dns-sniper
 version: !ruby/object:Gem::Version
-  version: 0.0.1.pre3
+  version: 0.0.1.pre8
 platform: ruby
 authors:
 - Brody Hoskins
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-11-01 00:00:00.000000000 Z
+date: 2021-06-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: down
@@ -54,24 +54,30 @@ files:
 - README.md
 - Rakefile
 - bin/dns-sniper
+- config.yml.example
 - dns-sniper.gemspec
 - lib/dns-sniper.rb
-- lib/dns-sniper/formatter.rb
-- lib/dns-sniper/formatters.rb
-- lib/dns-sniper/formatters/bind8.rb
-- lib/dns-sniper/formatters/dnsmasq.rb
-- lib/dns-sniper/formatters/hosts.rb
-- lib/dns-sniper/formatters/netgear.rb
-- lib/dns-sniper/formatters/text.rb
-- lib/dns-sniper/formatters/unbound.rb
+- lib/dns-sniper/exporter.rb
+- lib/dns-sniper/exporters.rb
+- lib/dns-sniper/exporters/bind8_exporter.rb
+- lib/dns-sniper/exporters/dnsmasq_exporter.rb
+- lib/dns-sniper/exporters/hosts_exporter.rb
+- lib/dns-sniper/exporters/netgear_exporter.rb
+- lib/dns-sniper/exporters/text_exporter.rb
+- lib/dns-sniper/exporters/unbound_exporter.rb
 - lib/dns-sniper/hostnames.rb
+- lib/dns-sniper/importer.rb
+- lib/dns-sniper/importers.rb
+- lib/dns-sniper/importers/configuration_importer.rb
+- lib/dns-sniper/importers/domains_importer.rb
+- lib/dns-sniper/importers/hosts_importer.rb
 homepage: https://github.com/brodyhoskins/dns-sniper
 licenses:
 - MIT
 metadata:
   homepage_uri: https://github.com/brodyhoskins/dns-sniper
   source_code_uri: https://github.com/brodyhoskins/dns-sniper
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -86,8 +92,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: 1.3.1
 requirements: []
-rubygems_version: 3.0.3
-signing_key: 
+rubygems_version: 3.2.15
+signing_key:
 specification_version: 4
 summary: Combine DNS blacklists into desired configuration format
 test_files: []

data/lib/dns-sniper/formatters.rb

@@ -1,30 +0,0 @@
-# frozen_string_literal: true
-
-module DNSSniper
-  module Formatters
-    extend self
-
-    attr_reader :registered
-    @registered = []
-
-    def register(class_name, autoload_require)
-      DNSSniper.autoload(class_name, autoload_require)
-      @registered << class_name
-    end
-
-    def all
-      @registered.map { |name| DNSSniper.const_get(name) }
-    end
-
-    def find(name)
-      all.find { |c| c.name.downcase == name.to_s.downcase } or raise NameError, "Unknown formatter \"#{name}\""
-    end
-  end
-end
-
-DNSSniper::Formatters.register :Bind8, 'dns-sniper/formatters/bind8'
-DNSSniper::Formatters.register :Dnsmasq, 'dns-sniper/formatters/dnsmasq'
-DNSSniper::Formatters.register :Hosts, 'dns-sniper/formatters/hosts'
-DNSSniper::Formatters.register :Netgear, 'dns-sniper/formatters/netgear'
-DNSSniper::Formatters.register :Text, 'dns-sniper/formatters/text'
-DNSSniper::Formatters.register :Unbound, 'dns-sniper/formatters/unbound'

data/lib/dns-sniper/formatters/text.rb

@@ -1,14 +0,0 @@
-# frozen_string_literal: true
-
-module DNSSniper
-  class Text < Formatter
-    def initialize(hostnames, options = {})
-      @hostnames = hostnames
-      @options = options
-    end
-
-    def output(_options = {})
-      @hostnames.to_a.join($/)
-    end
-  end
-end