dns-sniper 0.0.1.pre2 → 0.0.1.pre7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4e0cfd33b8c953620c67bd40ea77e26ed12f7a9a10716918ee130a87a8617975
-  data.tar.gz: 9c74827c20d2d3a6cef9ca2876eb9659475401088e05d963778eed19c6d11374
+  metadata.gz: fdb713f65960730a1ac99906c65aeb79b30b69514eedab948ee20eb27bf30920
+  data.tar.gz: 28d04385a9759e9bada850e6c4dde26d7f3d983ddedd9d5782d31c6001cab19d
 SHA512:
-  metadata.gz: 57d9eaeeb39531a8ec3a5ca9bc0ea21e4dd8277c97b7ecb01fbd49f3109db725efc58096ce60768fb20585d19de26880e34c97e10f2011d2e4ea4e58d09d8d00
-  data.tar.gz: e673010ec9e40910411c4cb63f9f018c70faff0704bc96fc060900cf1188d74df37571821509e06bc98b7092c31b6cf0c8fab615f78fe086ecf892f199ddbbd8
+  metadata.gz: c02d1bb299780f04041d8899aeb72b7457ec8954184c95a0bae61731c1b36763f44055b41d4e8115c42bf0ccfdb68b407db3aef5ff71a3dc0e01d8dde0bcee99
+  data.tar.gz: fd3f08b34762d39e3610ad23810736a667e83f7b77459d8508e625f67007b0fa7adcd028091c65c4f05e28f39eacc6d805313e6733c9d8592f4657b5ade50e2b

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.pre2'
-  spec.date = '2020-11-01'
+  spec.version = '0.0.1.pre7'
+  spec.date = '2021-07-26'
 
   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,18 +1,13 @@
 # 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])
 
       str = ''.dup
       @hostnames.each do |hostname|
-        str << "zone \"#{hostname}\" { type master; notify no; file \"#{options[:zone_file]}\"; };#{$INPUT_RECORD_SEPARATOR}"
+        str << "zone \"#{hostname}\" { type master; notify no; file \"#{options[:zone_file]}\"; };#{$/}"
       end
       str
     end

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

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

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

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

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/exporters/unbound_exporter.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module DNSSniper
+  class UnboundExporter < Exporter
+    def output(*)
+      str = ''.dup
+      str << "server:#{$/}"
+      @hostnames.each do |hostname|
+        str << "  local-zone: \"#{hostname}\" static#{$/}"
+      end
+      str
+    end
+  end
+end

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 [].to_set unless File.exist?(path)
+
+      yaml = YAML.safe_load(File.read(path), permitted_classes: [Symbol])
+      return [].to_set unless yaml.dig(:sources)&.dig(list.to_sym)
+
+      hostnames = [].to_set
+      yaml.dig(:sources).dig(list.to_sym).each do |source|
+        return [].to_set unless source.dig(:importer)
+        return [].to_set 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 [].to_set unless File.exist?(path)
+
+      File.open(path).readlines(chomp: true).map { |hostname| clean(hostname) }.reject { |hostname| rejector(hostname) }.to_set
+    end
+
+    def import_uri(uri)
+      begin
+        down = Down.download(uri)
+        return down.readlines(chomp: true).map { |hostname| clean(hostname) }.reject { |hostname| rejector(hostname) }.to_set
+      rescue Down::InvalidUrl => e
+        warn "#{self.class.name}: #{e}"
+      end
+
+      [].to_set
+    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 [].to_set unless File.exist?(path)
+
+      HostsFile.load(path).map(&:name).map { |hostname| clean(hostname) }.reject { |hostname| rejector(hostname) }.to_set
+    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) }.to_set
+      end
+
+      [].to_set
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dns-sniper
 version: !ruby/object:Gem::Version
-  version: 0.0.1.pre2
+  version: 0.0.1.pre7
 platform: ruby
 authors:
 - Brody Hoskins
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-11-01 00:00:00.000000000 Z
+date: 2021-07-26 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,31 +0,0 @@
-# frozen_string_literal: true
-
-module DNSSniper
-  module Formatters
-    extend self
-    # 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 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/dnsmasq.rb

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

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

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

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($INPUT_RECORD_SEPARATOR)
-    end
-  end
-end

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

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-module DNSSniper
-  class Unbound < Formatter
-    def initialize(hostnames, options = {})
-      @hostnames = hostnames
-      @options = options
-    end
-
-    def output(_options = {})
-      str = ''.dup
-      str << "server:#{$INPUT_RECORD_SEPARATOR}"
-      @hostnames.each do |hostname|
-        str << "  local-zone: \"#{hostname}\" static#{$INPUT_RECORD_SEPARATOR}"
-      end
-      str
-    end
-  end
-end