iparty 0.1.0

data/lib/iparty/cli/application/options.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+module IParty
+  module CLI
+    class Application
+      module Options
+        def default_options
+          {
+            debug: @argv.include?("--debug"),
+            stdin: false,        # --stdin
+            colorize: true,      # -m
+            summarize: true,     # -a
+            resolve: false,      # -r
+            action: :info,       # -d
+            formatter: "pretty", # -f
+            lang: "en",          # -l
+            only: [],            # -o
+            except: [],          # -e
+
+            # format latlong when summarizing (--no-a)
+            fmt_latlong: "https://www.google.com/maps?q=%f,%f",
+
+            # refresh stale mmdb files (:always, :missing, maxAge in seconds as Numeric)
+            mmdb_fetch_when: 14 * 24 * 60 * 60, # 14.days
+          }
+        end
+
+        def loadrc
+          if @rc_disabled
+            puts "[iparty-debug] skipping rc (disabled)" if @opts[:debug]
+            return
+          end
+
+          unless @config_file.exist? && @config_file.readable?
+            puts "[iparty-debug] skipping rc (inaccessible)" if @opts[:debug]
+            return
+          end
+
+          puts "[iparty-debug] eval'ing rc #{@config_file}" if @opts[:debug]
+          instance_eval @config_file.read(encoding: "utf-8"), @config_file.to_s
+        end
+
+        def require_resolv
+          require "resolv"
+        rescue LoadError
+          warn c("This iparty feature requires the resolv gem to be installed.", :red)
+          warn c("Resolution:", :yellow)
+          warn c("  gem install resolv", :blue)
+          exit 1
+        end
+
+        # rubocop:disable Layout/SpaceInsideParens, Metrics/AbcSize -- readability
+        def init_optparse
+          OptionParser.new do |opts|
+            opts.summary_width = 38
+            opts.banner = "Usage: iparty <IP|host...> [options]"
+
+            expression_help = [
+              c("** matches .*", :cyan),
+              c(" * matches [^.]*", :cyan),
+            ]
+
+            opts.separator("\n# Application options")
+            opts.on("-a", "--[no-]all", "full non-summarized output") {|v| @opts[:summarize] = !v }
+            opts.on("-f", "--format <FORMATTER>", String, "formatter (pretty|json|off) or template string [default: #{@opts[:formatter]}]") {|v| @opts[:formatter] = v }
+            opts.on("-l", "--language <LANG>", String, "limit output to language (or all) [default: #{@opts[:lang]}]") {|v| @opts[:lang] = v }
+            opts.on("-r", "--[no-]resolve", "resolve hosts and include hostnames in data (requires resolv)") {|v| @opts[:resolv] = v }
+            opts.on("-o", "--only   key,deep.key,*country*", Array, "list of key expressions (grep on full key)") {|v| @opts[:only] += v }
+            opts.on("-e", "--except key,deep.key,sub*", Array, "list of key expressions (grep_v on full key)", *expression_help) {|v| @opts[:except] += v }
+            opts.on(      "--[no-]stdin", "read from stdin (space/line separated IPs or hosts)") {|v| @opts[:stdin] = v }
+
+            opts.separator("\n# (Custom) actions")
+            opts.on("-d", "--dispatch ACTION", String, "Dispatch given action, you may add your own") {|v| @opts[:action] = v.to_sym }
+            opts.on(      "--irb", "IRB repl with iparty context and helpers") { @opts[:action] = :irb }
+
+            opts.separator("\n# MMDB actions")
+            opts.on(      "--mmdb-status", "Show mmdb file status") { exit(appinfo_mmdb_status ? 0 : 1) }
+            opts.on(      "--mmdb-fetch", "Fetch missing mmdb-editions") { ensure_mmdb_files! }
+            opts.on(      "--mmdb-update", "Update all mmdb-editions") { ensure_mmdb_files!(:always) }
+
+            opts.separator("\n# General options")
+            opts.on("-h", "--help", "Shows this help") { @opts[:action] = :help }
+            opts.on("-v", "--version", "Shows version and mmdb info (and config with --debug)") { @opts[:action] = :appinfo }
+            opts.on("-m", "--[no-]monochrome", "Don't or do colorize output") {|v| @opts[:colorize] = !v }
+            opts.on(      "--[no-]debug", "Enable debug, raise exceptions and print config with -v") {|v| @opts[:debug] = v }
+            opts.on(      "--no-rc", "Do not eval config.rb")
+          end
+        end
+        # rubocop:enable Layout/SpaceInsideParens, Metrics/AbcSize
+
+        def parse_options!
+          return @opts if @options_parsed
+
+          @options_parsed = true
+          @optparse.parse!(@argv)
+          require_resolv if @opts[:resolv]
+          @opts
+        rescue OptionParser::ParseError => ex
+          puts colorized_help_text, nil
+          @opts[:debug] ? raise(ex) : abort(c(ex.message, :red))
+        end
+
+        def colorized_help_text
+          @optparse.to_s.split("\n").map do |line|
+            if line.start_with?("Usage:")
+              words = line.split
+              [
+                colorize(words[0]),
+                colorize(words[1], :white),
+                colorize(words[2], :yellow),
+                colorize(words[3..].join(" "), :cyan),
+              ].join(" ")
+            elsif line.start_with?("#")
+              colorize(line, :blue)
+            elsif line.strip.start_with?("-")
+              summary_width = @optparse.summary_indent.length + @optparse.summary_width
+              optstr = line[...summary_width]
+              optdesc = line[summary_width..]
+              optdesc&.gsub!(/(\[default: [^\]]+\])/){ colorize(_1, :black) }
+
+              [
+                colorize(optstr, :cyan),
+                colorize(optdesc),
+              ].join
+            else
+              colorize(line)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/iparty/cli/application.rb

@@ -0,0 +1,258 @@
+# frozen_string_literal: true
+
+require "optparse"
+
+require_relative "formatter"
+require_relative "colorize"
+require_relative "application/options"
+require_relative "application/actions"
+require_relative "application/appinfo"
+require_relative "application/irb_context"
+
+module IParty
+  module CLI
+    class Application
+      class Error < ArgumentError; end
+      class ActionNotFound < Application::Error; end
+      class UnknownFormatter < Application::Error; end
+
+      include Application::Options
+      include Application::Actions
+      include Application::Appinfo
+      include Colorize
+
+      class DefaultOut
+        def push *args
+          puts(args.flatten.reject{ _1 == Formatter::VOID_OUTPUT })
+        end
+        alias_method :<<, :push
+      end
+
+      attr_reader :opts, :config_path, :config_file, :out, :env, :argv, :argf
+
+      def initialize(env:, argv:, argf:, **opts)
+        @env = env
+        @argv = argv
+        @argf = argf
+
+        @config_path = Pathname.new(env.fetch("IPARTY_CFGDIR", "~/.iparty")).expand_path
+        @config_file = @config_path.join("config.rb")
+        @opts = default_options.merge(opts)
+        @optparse = init_optparse
+        @options_parsed = false
+        @rc_disabled = @argv.delete("--no-rc")
+        @out = DefaultOut.new
+
+        loadrc
+        yield(self) if block_given?
+      end
+
+      def ensure_mmdb_files! fetch_when = @opts[:mmdb_fetch_when]
+        IParty::MaxMind.fetch_db_files!(fetch_when, verbose: true)
+      end
+
+      def stdin_select?
+        !$stdin.wait_readable(0).nil?
+      end
+
+      def read_from_stdin?
+        @opts[:stdin] || (@argv.empty? && stdin_select?)
+      end
+
+      def each_line_in_argf_as_addresses prompt: $stdin.tty?, ps1: "> "
+        index = 0
+        print ps1 if prompt
+
+        @argf.each_line do |line|
+          raise(Interrupt) if prompt && line.chomp.match?(/^(q|quit|exit)$/)
+
+          line.split(/\s+/).each do |chunk|
+            addresses = IParty.expand_hostnames(chunk)
+            yield(addresses, index)
+            index += addresses.length
+          end
+
+          if prompt
+            print ps1
+            index = 0
+          end
+        end
+      end
+
+      def each_address use_argf: read_from_stdin?, &block
+        if use_argf
+          each_line_in_argf_as_addresses do |addresses|
+            addresses.each(&block)
+          end
+        else
+          IParty.expand_hostnames(@argv).each(&block)
+        end
+      end
+
+      def build_formatter fmt = @opts[:formatter], **kw
+        if fmt.is_a?(CLI::Formatter)
+          fmt
+        elsif fmt.is_a?(Class)
+          fmt.new(self, **kw)
+        elsif fmt_class = CLI::Formatter.find_by_id(fmt)
+          fmt_class.new(self, argument: fmt, **kw)
+        else
+          raise UnknownFormatter, "unknown formatter: #{fmt}"
+        end
+      end
+
+      def formatter
+        @_formatter ||= build_formatter(@opts[:formatter], colorize: @opts[:colorize])
+      end
+
+      def ip_to_data ip, colorize: false
+        ipp = IParty(ip)
+
+        data = {
+          type: ipp.type,
+          prefix: ipp.prefix,
+          address: ipp.to_s,
+          cidr: ipp.to_cidr,
+        }
+
+        # -r --resolve
+        data[:hostname] = Resolv.getnames(ip).join(" ") if @opts[:resolv]
+
+        # merge geo data
+        data.merge!(ipp.as_json)
+
+        # -l --language
+        replace_names_with_singular_for!(@opts[:lang].to_s, data) if @opts[:lang] && @opts[:lang].to_s != "all"
+
+        # -a --all
+        data = summarize(data, colorize: colorize) if @opts[:summarize]
+
+        # -e --except
+        # -o --only
+        onlyexcept_data!(data)
+
+        data
+      rescue StandardError => ex
+        @opts[:debug] ? raise(ex) : { error_class: ex.class, error: ex.message }
+      end
+
+      def replace_names_with_singular_for!(lang, data)
+        case data
+        when Hash
+          if (names = data.dig(:names)) && (name = names.dig(lang.to_sym) || names.dig(:en))
+            data[:name] = name
+            data.delete(:names)
+          end
+
+          data.each_value { replace_names_with_singular_for!(lang, _1) }
+        when Array
+          data.each{ replace_names_with_singular_for!(lang, _1) }
+        end
+      end
+
+      def summarize data, colorize: @opts[:colorize]
+        with_color(colorize) do
+          latlong = [data.dig(:location, :latitude), data.dig(:location, :longitude)].compact
+
+          {
+            type: "#{data[:type]}[/#{data[:prefix]}]",
+            hostname: (data[:hostname] if data[:hostname] && !data[:hostname].empty?),
+            cidr: (data[:cidr] unless data[:cidr] == data[:address]),
+            network: summarize_network_detail(data),
+            name: data.dig(:annotations, :name),
+            tags: (data.dig(:annotations, :tags).join(" ") if data.dig(:annotations, :tags)&.any?),
+            location: summarize_location_detail(data),
+            time_zone: data.dig(:location, :time_zone),
+            latlong: (c((@opts[:fmt_latlong] || "%f, %f") % latlong, :magenta) unless latlong.empty?),
+          }.compact
+        end
+      end
+
+      def summarize_asn_detail data
+        return unless asn_number = data.dig(:autonomous_system_number)
+
+        asn_org = data.dig(:autonomous_system_organization)
+        asn_detail = c("AS#{asn_number} #{c(asn_org, :cyan)}")
+        asn_detail unless decolorize(asn_detail).empty?
+      end
+
+      def summarize_network_detail data
+        network_detail = [c(data[:network], :blue), summarize_asn_detail(data)].compact.join(c(" -- ", :black))
+        network_detail unless decolorize(network_detail).empty?
+      end
+
+      def summarize_location_detail data
+        continent_name = data.dig(:continent, :name) || data.dig(:continent, :names, :en)
+        country_name = data.dig(:country, :name) || data.dig(:country, :names, :en)
+        country_name ||= data.dig(:registered_country, :name) || data.dig(:registered_country, :names, :en)
+        city_name = data.dig(:city, :name) || data.dig(:city, :names, :en)
+
+        location_detail = [
+          (c(continent_name, :green) if continent_name),
+          (c(country_name, :yellow) if country_name),
+          ([c(data.dig(:postal, :code), :cyan), c(city_name, :blue)].compact.join(" ") if city_name),
+        ].compact.join(c(" / ", :black))
+
+        location_detail unless decolorize(location_detail).empty?
+      end
+
+      def onlyexcept_data! data
+        if @opts[:only] && matchers = create_matchers(@opts[:only])
+          deep_onlyexcept_data(data, matchers, keep: true)
+        end
+
+        if @opts[:except] && matchers = create_matchers(@opts[:except])
+          deep_onlyexcept_data(data, matchers, keep: false)
+        end
+
+        data
+      end
+
+      def create_matchers expressions
+        return if expressions.empty?
+
+        expressions.map do |exp|
+          /\A#{exp.gsub(/\*\*|\*/, { "**" => ".*", "*" => "[^.]*" })}\z/i
+        end
+      end
+
+      def deep_onlyexcept_data data, matchers, keep: true, keystack: []
+        case data
+        when Hash
+          data.delete_if {|k, v| _deep_onlyexcept_kv_match?(k, v, matchers, keep: keep, keystack: keystack) }
+        when Array
+          data.delete_if.with_index {|v, i| _deep_onlyexcept_kv_match?(i, v, matchers, keep: keep, keystack: keystack) }
+        end
+      end
+
+      def _deep_onlyexcept_kv_match? key, value, matchers, keep: true, keystack: []
+        fullkey = (keystack + [key]).join(".")
+
+        unless matched = matchers.any?{ fullkey.match?(_1) }
+          deep_onlyexcept_data(value, matchers, keep: keep, keystack: keystack + [key])
+        end
+
+        if keep
+          value.respond_to?(:each) ? !matched && value.empty? : !matched
+        else
+          matched || (value.respond_to?(:each) && value.empty?)
+        end
+      end
+
+      def dispatch action: nil
+        parse_options!
+        action ||= @opts[:action]
+        action_method = :"dispatch_#{action}"
+        raise ActionNotFound, "unknown action: #{action} (does not respond to ##{action_method})" unless respond_to?(action_method)
+
+        puts "[iparty-debug] dispatching #{action_method}" if @opts[:debug]
+        send(action_method)
+      rescue CLI::Application::Error => ex
+        appinfo_formatters(pad: 0) if ex.is_a?(CLI::Application::UnknownFormatter)
+        @opts[:debug] ? raise(ex) : abort(c(ex.message, :red))
+      rescue Interrupt, SystemExit => ex
+        raise(ex) if @opts[:debug]
+      end
+    end
+  end
+end

data/lib/iparty/cli/colorize.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module IParty
+  module CLI
+    module Colorize
+      class UnknownColorError < ArgumentError; end
+
+      COLORMAP = {
+        black: 30,
+        gray: 30,
+        red: 31,
+        green: 32,
+        yellow: 33,
+        blue: 34,
+        magenta: 35,
+        cyan: 36,
+        white: 37,
+      }.freeze
+
+      def colorize str, color = :yellow
+        ccode = COLORMAP[color.to_sym] || raise(UnknownColorError, "unknown color `#{color}'")
+        @opts[:colorize] ? "\e[#{ccode}m#{str}\e[0m" : str.to_s
+      end
+      alias_method :c, :colorize
+
+      def decolorize str
+        str.to_s.gsub(/\e\[.*?(\d)+m/, "")
+      end
+
+      def with_color *args
+        color_was = @opts[:colorize]
+        @opts[:colorize] = args.fetch(0, true)
+        yield
+      ensure
+        @opts[:colorize] = color_was
+      end
+    end
+  end
+end

data/lib/iparty/cli/formatter.rb

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+
+require_relative "colorize"
+
+module IParty
+  module CLI
+    class Formatter
+      VOID_OUTPUT = false
+
+      include Colorize
+
+      class << self
+        attr_writer :id
+
+        def id
+          @id || name.split("::").last
+        end
+
+        def descendants of: self
+          of.subclasses.flat_map{ [_1] + descendants(of: _1) }
+        end
+
+        def find_by_id input, of: self
+          descendants.detect do |fmt|
+            fmt.id === input # rubocop:disable Style/CaseEquality -- deliberate to support regex/proc also
+          end
+        end
+      end
+
+      def initialize(app, **opts)
+        @app = app
+        @opts = { colorize: true }.merge(opts)
+
+        setup if respond_to?(:setup)
+      end
+
+      def colorize?
+        @opts[:colorize]
+      end
+
+      def format_all ips, base_index: 0, **kw, &to_data
+        ips.map.with_index {|ip, index| format(ip, index: base_index + index, **kw, &to_data) }
+      end
+
+      def format ip, index: 0, **kw, &to_data
+        to_data.call(ip)
+      end
+
+      class NoOutput < Formatter
+        self.id = "off"
+
+        def format ip, **kw, &to_data
+          super # run to_data logic
+          VOID_OUTPUT
+        end
+      end
+
+      class ConsolePretty < Formatter
+        self.id = "pretty"
+
+        def setup
+          @opts[:align] = @app.opts[:summarize]
+        end
+
+        def format_all ips, base_index: 0, **kw, &to_data
+          ips.map.with_index do |ip, index|
+            [].tap do |r|
+              r << nil unless (base_index + index).zero?
+              next unless out = format(ip, index: base_index + index, **kw, &to_data)
+
+              indent_header = decolorize(out[0...(out.index(":") || 0)]).length - 1 if @opts[:align]
+              r << c("#{"".rjust(indent_header || 0, "=")}=> #{ip}", :red)
+
+              r << out
+            end
+          end
+        end
+
+        def format ip, index: 0, **kw, &to_data
+          out = to_indented_strings(to_data.call(ip), **kw).join("\n")
+          out = VOID_OUTPUT if out.empty?
+          out
+        end
+
+        def to_indented_strings value, key: nil, indent: -1, maxkeylength: 0, buf: []
+          indent_spaces = "".rjust(2 * indent, " ")
+
+          if value.is_a?(Hash)
+            buf << "#{indent_spaces}#{c(key.is_a?(Numeric) ? "[#{key}]" : "#{key}:")}" if key
+            maxkeylength = value.keys.map{ _1.to_s.length }.max if @opts[:align]
+            value.each do |k, v|
+              to_indented_strings(v, buf: buf, maxkeylength: maxkeylength, key: k, indent: indent + 1)
+            end
+          elsif value.is_a?(Array)
+            buf << "#{indent_spaces}#{c(key.is_a?(Numeric) ? "[#{key}]" : "#{key}:")}" if key
+            value.each_with_index do |v, i|
+              to_indented_strings(v, buf: buf, maxkeylength: maxkeylength, key: i, indent: indent + 1)
+            end
+          elsif key
+            buf << "#{indent_spaces}#{c(key.to_s.rjust(maxkeylength))}: #{c(value, :blue)}"
+          else
+            buf << "#{indent_spaces}#{c(value, :blue)}"
+          end
+
+          buf
+        end
+      end
+
+      class JsonFormatter < Formatter
+        self.id = "json"
+
+        def setup
+          @opts[:colorize] = false
+
+          require "json"
+        rescue LoadError
+          warn c("The iparty JSON output formatter requires the json gem to be installed.", :red)
+          warn c("Resolution:", :yellow)
+          warn c("  gem install json", :blue)
+          exit 1
+        end
+
+        def format_all ips, **kw, &to_data
+          data = ips.to_h {|ip| [ip, to_data.call(ip)] }
+          [JSON.pretty_generate(data)]
+        end
+
+        def format ip, **kw, &to_data
+          JSON.pretty_generate to_data.call(ip)
+        end
+      end
+
+      class StringFormatter < Formatter
+        self.id = /%{/
+
+        def format_all ips, base_index: 0, **kw, &to_data
+          ips.map.with_index {|ip, index| format(ip, index: base_index + index, **kw, &to_data) }
+        end
+
+        def format ip, index: 0, **kw, &to_data
+          data = to_data.call(ip)
+          locals = { 1 => ip }
+          fwd_hash = Hash.new do |_, key|
+            dig_loose_value(data, key, locals) || (@app.opts[:debug] ? nil : "")
+          end
+
+          out = @opts[:argument] % fwd_hash
+          out.empty? ? VOID_OUTPUT : out
+        end
+
+        def dig_loose_value data, key, locals = {}
+          key_part, def_val = key.to_s.split("|", 2)
+          chunks = key_part.split(".").map{ _1.match?(/\A-?\d+\z/) ? _1.to_i : _1.to_sym }
+
+          return locals.fetch(chunks[0]) if chunks.length == 1 && locals.key?(chunks[0])
+
+          dig_loose_value_in(data, chunks) || def_val
+        end
+
+        def dig_loose_value_in ptr, chunks
+          return ptr if chunks.empty?
+          return ptr unless ptr.is_a?(Hash) || ptr.is_a?(Array)
+
+          dig_loose_value_in(ptr[chunks[0]], chunks[1..])
+        end
+      end
+    end
+  end
+end