nomius 0.1.0

data/lib/nomius/bulk_checker.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require_relative "checker"
+require_relative "detector"
+require_relative "name"
+require_relative "logger/silent"
+require_relative "status/formatter/mark"
+
+module Nomius
+  # BulkChecker
+  class BulkChecker
+    RESULT = Struct.new(:name, :results, keyword_init: true)
+
+    attr_reader :names, :detectors, :logger
+
+    def self.check(*args, **kwargs)
+      new(*args, **kwargs).check
+    end
+
+    def initialize(names: [], detectors: Detector.all, logger: Logger::Silent.new)
+      @names = names.compact.map { |name| Name.for(name) }
+      @detectors = detectors
+      @logger = logger
+    end
+
+    def check
+      logger.start_batch_processing(names.count)
+
+      names.map do |name|
+        logger.batch_record_processing(name) do
+          RESULT.new(
+            name: name,
+            results: Checker.check(name: name, detectors: detectors, logger: logger)
+          )
+        end
+      end
+    end
+  end
+end

data/lib/nomius/checker.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative "detector"
+require_relative "name"
+require_relative "logger/silent"
+
+module Nomius
+  # Checker
+  class Checker
+    attr_reader :name, :detectors, :logger
+
+    def self.check(*args, **kwargs)
+      new(*args, **kwargs).check
+    end
+
+    def initialize(name:, detectors: Detector.all, logger: Logger::Silent.new)
+      @name = Name.for(name)
+      @detectors = detectors
+      @logger = logger
+    end
+
+    def check
+      detectors.map do |detector|
+        logger.log_detector_status do
+          detector.status(name: name, logger: logger)
+        end
+      end
+    end
+  end
+end

data/lib/nomius/cli/command.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require "tty-option"
+require_relative "../version"
+
+module Nomius
+  class CLI
+    # Console options parser
+    class Command
+      include TTY::Option
+
+      usage do
+        program "nomius"
+        no_command
+        desc "Nomius — bulk domain & package name availability checker."
+        example <<~DESCRIPTION
+          Basic usage
+          Check "firstname" and "othername" names.
+            $ nomius firstname othername
+
+          Usage with a TXT file
+            $ nomius --input names.txt
+          or
+            $ cat names.txt | nomius
+          or
+            $ nomius < names.txt
+
+          Usage with a CSV file
+            $ nomius --input names.csv
+
+          Usage with a CSV file and output to a CSV file
+            $ nomius --input names.csv --output results.csv
+        DESCRIPTION
+      end
+
+      flag :help do
+        short "-h"
+        long "--help"
+        desc "Print usage"
+      end
+
+      flag :silent do
+        short "-s"
+        long "--silent"
+        desc "Print less output"
+      end
+
+      flag :version do
+        long "--version"
+        desc "Print version"
+      end
+
+      option :input do
+        short "-i"
+        long "--input string"
+        desc <<~DESCRIPTION
+          Input file. Could be:
+          - TXT with each name on a separate line;
+          - CSV file with 2 columns: "name","comment" ("comment" is optional).
+        DESCRIPTION
+      end
+
+      option :output do
+        short "-o"
+        long "--output string"
+        desc "Output CSV file"
+      end
+
+      argument :names do
+        arity zero_or_more
+        # Read from STDIN to support piping.
+        default -> { $stdin.tty? ? [] : $stdin.each_line.to_a }
+        convert :list
+      end
+
+      def run
+        check_help!
+        check_version!
+        check_input!
+      end
+
+      private
+
+      def check_help!
+        return unless params[:help]
+
+        print help
+        exit
+      end
+
+      def check_version!
+        return unless params[:version]
+
+        puts Nomius::VERSION
+        exit
+      end
+
+      def check_input!
+        return unless params[:names].empty? && params[:input].nil?
+
+        print help
+        exit(1)
+      end
+    end
+  end
+end

data/lib/nomius/cli/parser/file_parser/csv_parser.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "csv"
+require_relative "../../../name"
+
+module Nomius
+  class CLI
+    class Parser
+      class FileParser
+        # Parser for CSV files
+        class CSVParser
+          attr_reader :file_name
+
+          def self.names(file_name:)
+            new(file_name: file_name).names
+          end
+
+          def initialize(file_name:)
+            @file_name = file_name
+          end
+
+          def names
+            CSV.read(file_name, skip_blanks: true, liberal_parsing: true).map do |name, comment|
+              Name.new(name: name, comment: comment)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/nomius/cli/parser/file_parser/txt_parser.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative "../../../name"
+
+module Nomius
+  class CLI
+    class Parser
+      class FileParser
+        # Parser for TXT files
+        class TXTParser
+          attr_reader :file_name
+
+          def self.names(file_name:)
+            new(file_name: file_name).names
+          end
+
+          def initialize(file_name:)
+            @file_name = file_name
+          end
+
+          def names
+            cleared_names.map do |name|
+              Name.new(name: name)
+            end
+          end
+
+          private
+
+          def cleared_names
+            File
+              .readlines(file_name)
+              .reject { |name| name.strip.empty? }
+              .sort
+              .uniq
+          end
+        end
+      end
+    end
+  end
+end

data/lib/nomius/cli/parser/file_parser.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative "../../name"
+require_relative "file_parser/txt_parser"
+require_relative "file_parser/csv_parser"
+
+module Nomius
+  class CLI
+    class Parser
+      # Parser for files
+      class FileParser
+        FALLBACK_PARSER = TXTParser
+
+        PARSER_BY_FILE_EXTENSION = {
+          ".csv" => CSVParser
+        }.freeze
+
+        def self.names(file_name:, **_kwargs)
+          PARSER_BY_FILE_EXTENSION
+            .fetch(File.extname(file_name), FALLBACK_PARSER)
+            .new(file_name: file_name)
+            .names
+        end
+      end
+    end
+  end
+end

data/lib/nomius/cli/parser/strings_parser.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative "../../name"
+
+module Nomius
+  class CLI
+    class Parser
+      # Parser for array of strings
+      class StringsParser
+        def self.names(strings:, **_kwargs)
+          new(strings: strings).names
+        end
+
+        def initialize(strings:, **_kwargs)
+          @strings = strings
+        end
+
+        def names
+          cleared_names.map do |name|
+            Name.new(name: name)
+          end
+        end
+
+        private
+
+        attr_reader :strings
+
+        def cleared_names
+          strings
+            .reject { |name| name.strip.empty? }
+            .sort
+            .uniq
+        end
+      end
+    end
+  end
+end

data/lib/nomius/cli/parser.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative "parser/file_parser"
+require_relative "parser/strings_parser"
+
+module Nomius
+  class CLI
+    # ParserChooser
+    class Parser
+      PARSER_BY_INPUT_FILE_PRESENCE = {
+        true => FileParser,
+        false => StringsParser
+      }.freeze
+
+      def self.names(file_name: nil, strings: [])
+        PARSER_BY_INPUT_FILE_PRESENCE
+          .fetch(!file_name.nil?)
+          .names(file_name: file_name, strings: strings)
+      end
+    end
+  end
+end

data/lib/nomius/cli/runner.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require_relative "parser"
+require_relative "writer/console_writer"
+require_relative "writer/csv_writer"
+require_relative "../bulk_checker"
+require_relative "../logger"
+
+module Nomius
+  class CLI
+    # CLI Runner
+    class Runner
+      attr_reader :names, :silent, :input, :output
+
+      def self.run(*args, **kwargs)
+        new(*args, **kwargs).run
+      end
+
+      def initialize(names: [], silent: false, input: nil, output: nil)
+        @names = names
+        @silent = silent
+        @input = input
+        @output = output
+      end
+
+      def run
+        logger = Logger.for(silent: silent)
+        writers = [Writer::ConsoleWriter]
+        writers << Writer::CSVWriter if output
+
+        results = BulkChecker.check(
+          names: Parser.names(file_name: input, strings: names),
+          logger: logger
+        )
+
+        writers.each do |writer|
+          writer.write!(results: results, file_name: output)
+        end
+      end
+    end
+  end
+end

data/lib/nomius/cli/writer/console_writer.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require "tty-table"
+require_relative "../../status/formatter/mark"
+
+module Nomius
+  class CLI
+    class Writer
+      # ConsoleWriter
+      class ConsoleWriter
+        attr_reader :results
+
+        TTY_TABLE_WIDTH = {
+          "fixed" => 80,
+          "flexible" => nil
+        }.freeze
+
+        TTY_TABLE_OPTIONS = {
+          padding: [0, 1],
+          multiline: true,
+          width: TTY_TABLE_WIDTH.fetch(ENV.fetch("TTY_TABLE_WIDTH", "flexible"))
+        }.compact.freeze
+
+        def self.write!(*args, **kwargs)
+          new(*args, **kwargs).write!
+        end
+
+        def initialize(results: [], **_kwargs)
+          @results = results
+        end
+
+        def write!
+          table = TTY::Table.new(headers, rows)
+          renderer = TTY::Table::Renderer::Unicode.new(table, TTY_TABLE_OPTIONS)
+
+          puts renderer.render
+        end
+
+        private
+
+        def headers
+          [
+            "Name",
+            *results.first.results.map(&:detector).map(&:detector_short_name),
+            "Comment"
+          ]
+        end
+
+        def rows
+          results.map do |result|
+            [
+              result.name.name,
+              *result.results.map { |status| status_mark_cell(status) },
+              result.name.comment
+            ]
+          end
+        end
+
+        def status_mark_cell(status)
+          {
+            value: Status::Formatter::Mark.for(status),
+            alignment: :center
+          }
+        end
+      end
+    end
+  end
+end

data/lib/nomius/cli/writer/csv_writer.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require "csv"
+require_relative "../../status/formatter/ascii_mark"
+
+module Nomius
+  class CLI
+    class Writer
+      # CSVWriter
+      class CSVWriter
+        attr_reader :results, :file_name
+
+        def self.write!(*args, **kwargs)
+          new(*args, **kwargs).write!
+        end
+
+        def initialize(file_name:, results: [], **_kwargs)
+          @results = results
+          @file_name = file_name
+        end
+
+        def write!
+          CSV.open(file_name, "w") do |f|
+            f << headers
+            rows.each { |row| f << row }
+          end
+        end
+
+        private
+
+        def headers
+          [
+            "Name",
+            "Comment",
+            *results.first.results.map(&:detector).map(&:detector_name)
+          ]
+        end
+
+        def rows
+          results.map do |result|
+            [
+              result.name.name,
+              result.name.comment,
+              *result.results.map { |status| Status::Formatter::ASCIIMark.for(status) }
+            ]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/nomius/cli.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_relative "cli/command"
+require_relative "cli/runner"
+
+module Nomius
+  # CLI
+  class CLI
+    attr_reader :names, :silent, :input, :output
+
+    def self.run(args = ARGV)
+      cmd = Command.new.parse(args)
+      cmd.run
+      params = cmd.params
+
+      Runner.run(
+        names: params[:names],
+        silent: params[:silent],
+        input: params[:input],
+        output: params[:output]
+      )
+    end
+  end
+end

data/lib/nomius/detector/base_domain_name_detector.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require "resolv"
+require "retriable"
+require "whois"
+require "whois-parser"
+require_relative "../status"
+
+module Nomius
+  class Detector
+    # Detects domain is taken.
+    # Works in 2 steps:
+    # 1. Resolve DNS A record.
+    # 2. If there is no A record, check WHOIS record.
+    class BaseDomainNameDetector
+      # NOTE: OpenDNS servers (https://www.opendns.com/)
+      NANE_SERVERS = ["208.67.222.222", "208.67.220.220"].freeze
+
+      STATUS_RESOLVER = {
+        true => Status::Available,
+        false => Status::Unavailable
+      }.freeze
+
+      attr_reader :name, :logger
+
+      def self.status(*args, **kwargs)
+        new(*args, **kwargs).status
+      end
+
+      def initialize(name:, logger: Logger::Silent)
+        @name = name
+        @logger = logger
+      end
+
+      def tld
+        ".org"
+      end
+
+      def detector_name
+        "#{name.name}#{tld}"
+      end
+
+      def detector_short_name
+        tld
+      end
+
+      def status
+        status_class.new(name: name, detector: self)
+      end
+
+      private
+
+      def status_class
+        STATUS_RESOLVER.fetch(availabile_by_dns? && availabile_by_whois?)
+      rescue Whois::ConnectionError, Whois::ParserError, Timeout::Error => e
+        logger.log_error(message: "Can't resolve: #{full_domain_name}", detalis: e.message)
+        Status::Unresolved
+      end
+
+      def full_domain_name
+        "#{name.name}#{tld}"
+      end
+
+      def availabile_by_dns?
+        Resolv::DNS
+          .new(nameserver: NANE_SERVERS)
+          .getresources(Resolv::DNS::Name.create(full_domain_name), Resolv::DNS::Resource::IN::SOA)
+          .empty?
+      end
+
+      def availabile_by_whois?
+        Retriable.retriable(
+          on: [Whois::ConnectionError, Timeout::Error],
+          tries: 6, multiplier: 2, base_interval: 1
+        ) do
+          Whois.whois(full_domain_name).parser.available?
+        end
+      rescue Whois::ParserError => e
+        # NOTE: Hotfix for whois-parser broken parser for .org.
+        return true if e.message.include?("Domain not found")
+
+        raise e
+      end
+    end
+  end
+end

data/lib/nomius/detector/base_url_detector.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require_relative "../status"
+require_relative "util/http_requester"
+module Nomius
+  class Detector
+    # Base class for detectors.
+    class BaseURLDetector
+      STATUS_RESOLVER = {
+        Util::HTTPRequester::NotFound => Status::Available,
+        Util::HTTPRequester::OK => Status::Unavailable,
+        Util::HTTPRequester::Unresolved => Status::Unresolved
+      }.freeze
+
+      attr_reader :name, :logger
+
+      def self.status(*args, **kwargs)
+        new(*args, **kwargs).status
+      end
+
+      def initialize(name:, logger: Logger::Silent, http_requester: Util::HTTPRequester)
+        @name = name
+        @logger = logger
+        @http_requester = http_requester
+      end
+
+      def detector_name
+        "Undefined"
+      end
+
+      def detector_short_name
+        "Undefined"
+      end
+
+      def status
+        STATUS_RESOLVER
+          .fetch(http_requester.response_status(uri: uri, logger: logger))
+          .new(name: name, detector: self)
+      end
+
+      private
+
+      attr_reader :http_requester
+    end
+  end
+end

data/lib/nomius/detector/dockerhub_detector.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require_relative "base_url_detector"
+
+module Nomius
+  class Detector
+    # Check name availability for https://hub.docker.com/
+    class DockerhubDetector < BaseURLDetector
+      BASE_URL = "https://hub.docker.com/v2/orgs"
+
+      def detector_name
+        "hub.docker.com"
+      end
+
+      def detector_short_name
+        "Docker"
+      end
+
+      private
+
+      def uri
+        "#{BASE_URL}/#{name.name}"
+      end
+    end
+  end
+end

data/lib/nomius/detector/domain_com_detector.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require "uri"
+require_relative "base_domain_name_detector"
+
+module Nomius
+  class Detector
+    # Check .com domain name availability
+    class DomainComDetector < BaseDomainNameDetector
+      def tld
+        ".com"
+      end
+    end
+  end
+end