Improvements (#5)

* Fix IPv6 :: expansion and add tests

* Add CHANGELOG

* Linked CHANGELOG in README

* Fix IPv6 parsing / broadcast and expand tests

* Fix IPv6 host range and add regression tests

* Fix IPv4 /0 handling and tighten IPv4 parsing

* Add IPv6 enhancements, netmask CIDR, JSON CLI and tests

* Add JSON metadata, stdin/compact CLI modes, and docs/tests

Author: vschwaberow

CHANGELOG.md

@@ -0,0 +1,40 @@
+# Changelog
+
+## 0.1.5
+- Fix IPv6 `::` expansion to produce correct 8-segment addresses and add regression tests.
+- Fix IPv6 broadcast calculation for non-byte-aligned CIDR and add regression test.
+- Fix IPv6 host range to be computed from the network address and add regression test.
+- Fix IPv4 /0 netmask and host range calculation and add regression test.
+- Reject IPv4 segments that contain trailing junk (e.g., `/24`).
+- Add IPv6 compressed output formatting and IPv4-mapped IPv6 parsing with stricter validation.
+- Expand IPv6 scope detection and /127 host range behavior.
+- Support IPv4 netmask notation in CIDR parsing.
+- Add `--json` and `--ip` CLI options.
+- Add tests for compressed IPv6 forms, non-byte-aligned IPv6 ranges, IPv4 /31, and netmask parsing.
+- Add JSON schema/version fields and stdin/compact/no-color CLI modes.
+- Add tests and docs for IPv4-mapped IPv6 and stdin/JSON output.
+- Add changelog and bump displayed version to 0.1.5.
+
+## 0.1.4
+- Development (#4).
+- Correct version metadata.
+
+## 0.1.3
+- Development (#3).
+- Add GitHub Actions workflow for build and test on release.
+- Enable manual triggering of build and test workflow.
+- Remove FreeBSD from build matrix and update dependency installation steps.
+- Update C++ standard from 26 to 23 in CMakeLists.txt.
+- Include `<limits>` header for IPv4 network calculation.
+- Disable fail-fast in build matrix for improved workflow stability.
+
+## 0.1.2
+- Add IPv4 network and broadcast calculation methods (#2).
+
+## 0.1.1
+- Add IPv6 support (#1).
+- Fix a README mistake.
+
+## 0.1.0
+- Add `cmake` directory.
+- Initial commit.

README.md

@@ -10,6 +10,9 @@ IP Analyzer is a command-line tool that provides detailed information about IP a
 - Calculate usable IP range and number of hosts
 - Determine if the IP address is private
 - Present results in a colorful, easy-to-read format
+- Support IPv4 netmask notation (e.g., `/255.255.255.0`)
+- Offer JSON output and non-interactive `--ip` and `--stdin` modes
+- Provide `--compact` and `--no-color` output modes
 
 ## Prerequisites
 
@@ -57,6 +60,20 @@ Enter an IP address with CIDR notation: 192.168.178.0/24
 
 When prompted, enter an IP address with or without CIDR notation. The tool will automatically detect whether it's an IPv4 or IPv6 address.
 
+You can also run non-interactively:
+
+```bash
+./build/ip-analyzer --ip 192.168.1.1/24 --json
+```
+
+The JSON output includes a schema identifier (`ip-analyzer/1`) and the app version.
+
+You can process multiple inputs from stdin:
+
+```bash
+printf "192.168.1.1/24\n2001:db8::1/64\n" | ./build/ip-analyzer --stdin --compact
+```
+
 ## Examples
 
 ### IPv4 Example
@@ -71,14 +88,18 @@ The IP Analyzer supports various IPv6 address formats, including:
 
 - Full notation: `2001:0db8:85a3:0000:0000:8a2e:0370:7334`
 - Compressed notation: `2001:db8:85a3::8a2e:370:7334`
-- IPv4-mapped IPv6 addresses: `::ffff:192.0.2.128`
+- IPv4-mapped IPv6 addresses: `::ffff:192.0.2.128` (outputs as `::ffff:192.0.2.128`)
 
 The program will display detailed information about the IP address.
 
 ## License
 
 This project is licensed under the MIT License. See the [LICENSE](LICENSE) file for details.
 
+## Changelog
+
+Release notes are tracked in [CHANGELOG.md](CHANGELOG.md).
+
 ## Pull Requests
 
 If you find a bug or want to contribute to the project, feel free to submit a pull request.

src/cli_app.cc

@@ -8,8 +8,14 @@
 
 namespace ip_analyzer {
 
-void PrintCopperBar()
+void PrintCopperBar(bool color_enabled)
 {
+    if (!color_enabled)
+    {
+        fmt::print("{}\n", std::string(kWidth, '='));
+        return;
+    }
+
     const auto copper_gradient = [](int i)
     {
         constexpr int kMaxColor = 255;
@@ -26,30 +32,66 @@ void PrintCopperBar()
     fmt::print("\n");
 }
 
-void PrintHeader(const std::string &text)
+void PrintHeader(const std::string &text, bool color_enabled)
 {
-    PrintCopperBar();
-    fmt::print(OutputColors::kHeader, "{:^{}}\n", text, kWidth);
-    PrintCopperBar();
+    PrintCopperBar(color_enabled);
+    if (color_enabled)
+    {
+        fmt::print(OutputColors::kHeader, "{:^{}}\n", text, kWidth);
+    }
+    else
+    {
+        fmt::print("{:^{}}\n", text, kWidth);
+    }
+    PrintCopperBar(color_enabled);
 }
 
-void PrintRow(const std::string &label, const std::string &value, const std::string &binary)
+void PrintRow(const std::string &label, const std::string &value, const std::string &binary,
+              bool color_enabled)
 {
-    fmt::print(OutputColors::kLabel, "{:<20}", label);
+    if (color_enabled)
+    {
+        fmt::print(OutputColors::kLabel, "{:<20}", label);
+    }
+    else
+    {
+        fmt::print("{:<20}", label);
+    }
     if (binary.empty())
     {
-        fmt::print(OutputColors::kValue, "{}\n", value);
+        if (color_enabled)
+        {
+            fmt::print(OutputColors::kValue, "{}\n", value);
+        }
+        else
+        {
+            fmt::print("{}\n", value);
+        }
     }
     else
     {
-        fmt::print(OutputColors::kValue, "{:<20}", value);
-        fmt::print(OutputColors::kBinary, "{}\n", binary);
+        if (color_enabled)
+        {
+            fmt::print(OutputColors::kValue, "{:<20}", value);
+            fmt::print(OutputColors::kBinary, "{}\n", binary);
+        }
+        else
+        {
+            fmt::print("{:<20}{}\n", value, binary);
+        }
     }
 }
 
 void IPAnalyzerApp::PrintPrompt() const
 {
-    fmt::print(OutputColors::kPrompt, "Enter IP address with CIDR (e.g., 192.168.0.1/24): ");
+    if (color_enabled_)
+    {
+        fmt::print(OutputColors::kPrompt, "Enter IP address with CIDR (e.g., 192.168.0.1/24): ");
+    }
+    else
+    {
+        fmt::print("Enter IP address with CIDR (e.g., 192.168.0.1/24): ");
+    }
 }
 
 void IPAnalyzerApp::PrintVersion() const
@@ -65,14 +107,23 @@ void IPAnalyzerApp::PrintHelp() const
     fmt::print("Options:\n");
     fmt::print("  -h, --help     Show this help message and exit\n");
     fmt::print("  -v, --version  Show version information and exit\n\n");
+    fmt::print("  --json         Output results as JSON\n");
+    fmt::print("  --compact      Use compact, non-decorated output\n");
+    fmt::print("  --no-color     Disable colored output\n");
+    fmt::print("  --stdin        Read IP/CIDR values from stdin\n");
+    fmt::print("  --ip <value>   Provide the IP/CIDR without prompting\n\n");
     fmt::print("Examples:\n");
     fmt::print("  {} 192.168.1.1/24\n", kAppName);
     fmt::print("  {} 2001:db8::1/64\n", kAppName);
+    fmt::print("  {} 2001:db8::/64\n", kAppName);
 }
 
 void IPAnalyzerApp::PrintResults(const IPAnalyzer &analyzer) const
 {
-    PrintHeader("IP Analysis Results");
+    if (!compact_)
+    {
+        PrintHeader("IP Analysis Results", color_enabled_);
+    }
 
     const auto ip = analyzer.get_ip();
     const auto [first, last] = analyzer.get_host_range();
@@ -95,20 +146,147 @@ void IPAnalyzerApp::PrintResults(const IPAnalyzer &analyzer) const
         rows.emplace_back("Broadcast Address", analyzer.get_broadcast()->to_string(), "");
     }
 
-    for (const auto &[label, value, binary] : rows)
+    if (compact_)
+    {
+        for (const auto &[label, value, binary] : rows)
+        {
+            fmt::print("{}: {}\n", label, value);
+        }
+    }
+    else
+    {
+        for (const auto &[label, value, binary] : rows)
+        {
+            PrintRow(label, value, binary, color_enabled_);
+        }
+    }
+
+    if (!compact_)
+    {
+        PrintCopperBar(color_enabled_);
+    }
+}
+
+void IPAnalyzerApp::PrintJsonResults(const IPAnalyzer &analyzer) const
+{
+    PrintJsonObject(analyzer, "", false);
+}
+
+void IPAnalyzerApp::PrintJsonObject(const IPAnalyzer &analyzer, const std::string &indent,
+                                    bool trailing_comma) const
+{
+    const auto ip = analyzer.get_ip();
+    const auto [first, last] = analyzer.get_host_range();
+
+    fmt::print("{}{{\n", indent);
+    fmt::print("{}  \"schema\": \"ip-analyzer/1\",\n", indent);
+    fmt::print("{}  \"version\": \"{}\",\n", indent, kVersion);
+    fmt::print("{}  \"ip\": \"{}\",\n", indent, ip->to_string());
+    fmt::print("{}  \"network\": \"{}\",\n", indent, analyzer.get_network()->to_string());
+    fmt::print("{}  \"netmask\": \"{}\",\n", indent, analyzer.get_netmask()->to_string());
+    fmt::print("{}  \"cidr\": {},\n", indent, analyzer.get_cidr());
+    fmt::print("{}  \"range_first\": \"{}\",\n", indent, first->to_string());
+    fmt::print("{}  \"range_last\": \"{}\",\n", indent, last->to_string());
+    fmt::print("{}  \"num_hosts\": {},\n", indent, analyzer.get_num_hosts());
+    fmt::print("{}  \"private\": {},\n", indent, analyzer.is_private() ? "true" : "false");
+
+    if (ip->is_ipv6())
+    {
+        fmt::print("{}  \"scope\": \"{}\"\n", indent, GetIPv6Scope(ip));
+    }
+    else
+    {
+        fmt::print("{}  \"broadcast\": \"{}\"\n", indent, analyzer.get_broadcast()->to_string());
+    }
+
+    fmt::print("{}}}{}\n", indent, trailing_comma ? "," : "");
+}
+
+int IPAnalyzerApp::RunFromStdin()
+{
+    std::vector<std::string> inputs;
+    std::string line;
+    while (std::getline(std::cin, line))
+    {
+        if (!line.empty())
+        {
+            inputs.push_back(line);
+        }
+    }
+
+    if (inputs.empty())
     {
-        PrintRow(label, value, binary);
+        return 1;
     }
 
-    PrintCopperBar();
+    if (output_json_)
+    {
+        fmt::print("[\n");
+    }
+
+    for (size_t index = 0; index < inputs.size(); ++index)
+    {
+        try
+        {
+            IPAnalyzer analyzer(inputs[index]);
+            if (output_json_)
+            {
+                PrintJsonObject(analyzer, "  ", index + 1 < inputs.size());
+            }
+            else
+            {
+                if (index > 0)
+                {
+                    fmt::print("\n");
+                }
+                PrintResults(analyzer);
+            }
+        }
+        catch (const std::exception &e)
+        {
+            if (output_json_)
+            {
+                fmt::print("]\n");
+            }
+            PrintError(e.what());
+            return 1;
+        }
+    }
+
+    if (output_json_)
+    {
+        fmt::print("]\n");
+    }
+
+    return 0;
 }
 
 std::string IPAnalyzerApp::GetIPv6Scope(const std::shared_ptr<IPAddress> &ip) const
 {
     auto ipv6 = std::dynamic_pointer_cast<IPv6Address>(ip);
     auto bytes = ipv6->to_bytes();
+    bool is_unspecified = true;
+    for (auto byte : bytes)
+    {
+        if (byte != 0)
+        {
+            is_unspecified = false;
+            break;
+        }
+    }
+    if (is_unspecified)
+        return "Unspecified";
+    if (bytes[0] == 0 && bytes[1] == 0 && bytes[2] == 0 && bytes[3] == 0 &&
+        bytes[4] == 0 && bytes[5] == 0 && bytes[6] == 0 && bytes[7] == 0 &&
+        bytes[8] == 0 && bytes[9] == 0 && bytes[10] == 0 && bytes[11] == 0 &&
+        bytes[12] == 0 && bytes[13] == 0 && bytes[14] == 0 && bytes[15] == 1)
+        return "Loopback";
+    if (bytes[0] == 0x20 && bytes[1] == 0x01 && bytes[2] == 0x0d && bytes[3] == 0xb8)
+        return "Documentation";
     if (bytes[0] == 0xfe && (bytes[1] & 0xc0) == 0x80)
         return "Link-Local";
+    if (bytes[0] == 0xfe && (bytes[1] & 0xc0) == 0xc0)
+        return "Site-Local";
     if (bytes[0] == 0xfd || bytes[0] == 0xfc)
         return "Unique Local";
     if (bytes[0] == 0xff)
@@ -118,7 +296,14 @@ std::string IPAnalyzerApp::GetIPv6Scope(const std::shared_ptr<IPAddress> &ip) co
 
 void IPAnalyzerApp::PrintError(const std::string &message) const
 {
-    fmt::print(OutputColors::kError, "Error: {}\n", message);
+    if (color_enabled_)
+    {
+        fmt::print(OutputColors::kError, "Error: {}\n", message);
+    }
+    else
+    {
+        fmt::print("Error: {}\n", message);
+    }
 }
 
-}
+}