node_info 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 4690a424588b5c969cb683f7654b483309d77f4e2777c05a21e3ee4ff951b013
+  data.tar.gz: 1546ca79fdc1328aa67959c3c669b01293369517e289ca2d484f45cdf651686e
+SHA512:
+  metadata.gz: 00a2b5e77d6a1c0a7ed548115577741270818bce97e0224177fcefaa8b7413d5f14204fa82827d3276bd3d4aa467064138d02a0910907c7391ccd898ae22393e
+  data.tar.gz: e2ee65ca80208387a34a230bfeca423066724405b7a6f5a8c7375278665a8ab20e5e3de6bbfde05a1b17c2689bb83a0b7875de0b2492720556e3b7f5cd93f765

data/CHANGELOG.md

@@ -0,0 +1,19 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this gem uses to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+## [0.1.0] - 2026-02-17
+
+### Added
+
+- Initial release
+- NodeInfo 2.1 client implementation
+- NodeInfo 2.1 server implementation
+- Support for well-known discovery
+- Pretty thorough test suite
+- Documentation and examples

data/README.md

@@ -0,0 +1,364 @@
+# NodeInfo
+
+[NodeInfo](https://nodeinfo.diaspora.software)
+is a standardized way for Fediverse servers to expose metadata about themselves,
+including software information, supported protocols, usage statistics, and more.
+
+A pure Ruby implementation of the NodeInfo protocol for the Fediverse,
+providing both client and server functionality.
+This gem implements NodeInfo 2.1 as specified in
+[FEP-f1d5](https://codeberg.org/fediverse/fep/src/branch/main/fep/f1d5/fep-f1d5.md).
+
+## Features
+
+- Pure Ruby     - Works with any Ruby framework or plain scripts
+- Client        - Discover and fetch `NodeInfo` from any Fediverse server
+- Server        - Serve your own `NodeInfo` documents
+- Dynamic Stats - Support for static values or dynamic procs for usage statistics
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'node_info'
+```
+
+And then execute:
+
+```ruby
+bundle install
+```
+
+Or install it yourself as:
+
+```ruby
+gem install node_info
+```
+
+## Usage
+
+### Client
+
+Fetch NodeInfo from any Fediverse server:
+
+```ruby
+require 'node_info'
+
+# Create a client
+client = NodeInfo::Client.new
+
+# Fetch NodeInfo from a server
+info = client.fetch 'mastodon.social'
+
+# Access the information
+puts info.software.name      # => 'mastodon'
+puts info.software.version   # => '4.2.0'
+puts info.protocols          # => ['activitypub']
+puts info.open_registrations # => true
+
+# Access usage statistics
+puts info.usage.users[:total]       # => 1000000
+puts info.usage.users[:activeMonth] # => 50000
+puts info.usage.local_posts         # => 5000000
+```
+
+#### Discovery and Fetching Separately
+
+```ruby
+# Discover the NodeInfo URL
+url = client.discover 'mastodon.social'
+# => 'https://mastodon.social/nodeinfo/2.1'
+
+# Fetch the NodeInfo document
+info = client.fetch_document url
+```
+
+#### Client Options
+
+```ruby
+# Custom timeout (default: 10 seconds)
+client = NodeInfo::Client.new timeout: 5
+
+# Disable redirect following (default: true)
+client = NodeInfo::Client.new follow_redirects: false
+```
+
+### Server
+
+Serve NodeInfo documents from your application:
+
+```ruby
+require 'node_info'
+
+# Create a server with configuration
+server = NodeInfo::Server.new do |config|
+  config.software_name       = 'example_app'
+  config.software_version    = '1.0.0'
+  config.software_repository = 'https://github.com/xoengineering/example'
+  config.software_homepage   = 'https://example.com'
+
+  config.protocols           = ['activitypub']
+  config.services_inbound    = ['atom1.0']
+  config.services_outbound   = ['rss2.0', 'atom1.0']
+  config.open_registrations  = true
+
+  config.metadata = {
+    nodeName:        'An example instance',
+    nodeDescription: 'An example place for exemplar people'
+  }
+end
+
+# Generate the well-known response: /.well-known/nodeinfo
+server.well_known_json 'https://example.com'
+# => {
+#   "links": [
+#     {
+#       "rel": "http://nodeinfo.diaspora.software/ns/schema/2.1",
+#       "href": "https://example.com/nodeinfo/2.1"
+#     }
+#   ]
+# }
+
+# Generate the NodeInfo document (/nodeinfo/2.1)
+server.to_json
+# => Full NodeInfo 2.1 JSON document
+```
+
+#### Static Usage Statistics
+
+```ruby
+server = NodeInfo::Server.new do |config|
+  config.software_name    = 'example_app'
+  config.software_version = '1.0.0'
+  config.protocols        = ['activitypub']
+
+  # Static values
+  config.usage_users          = { total: 100, activeMonth: 50, activeHalfyear: 75 }
+  config.usage_local_posts    = 1000
+  config.usage_local_comments = 500
+end
+```
+
+#### Dynamic Usage Statistics
+
+For production applications, you’ll want to compute statistics dynamically:
+
+```ruby
+server = NodeInfo::Server.new do |config|
+  config.software_name    = 'example_app'
+  config.software_version = '1.0.0'
+  config.protocols        = ['activitypub']
+
+  # Use procs to compute values dynamically
+  config.usage_users                 = -> { User.count }
+  config.usage_users_active_month    = -> { User.active_last_month.count }
+  config.usage_users_active_halfyear = -> { User.active_last_six_months.count }
+  config.usage_local_posts           = -> { Post.local.count }
+  config.usage_local_comments        = -> { Comment.local.count }
+end
+
+# Stats are computed fresh each time
+server.to_json # Calls all the procs to get current values
+```
+
+#### Alternative Proc Syntax
+
+```ruby
+config.usage_users = {
+  total:          -> { User.count },
+  activeMonth:    -> { User.active_last_month.count },
+  activeHalfyear: -> { User.active_last_six_months.count }
+}
+```
+
+### Framework Integration
+
+#### Sinatra
+
+```ruby
+require 'sinatra'
+require 'node_info'
+
+# Configure your server (perhaps in a config file or initializer)
+NODE_INFO_SERVER = NodeInfo::Server.new do |config|
+  config.software_name    = 'example_app'
+  config.software_version = '1.0.0'
+  config.protocols        = ['activitypub']
+  config.base_url         = 'https://example.com'
+  config.usage_users      = -> { User.count }
+end
+
+# Well-known endpoint
+get '/.well-known/nodeinfo' do
+  content_type :json
+  NODE_INFO_SERVER.well_known_json
+end
+
+# NodeInfo document endpoint
+get '/nodeinfo/2.1' do
+  content_type :json
+  NODE_INFO_SERVER.to_json
+end
+```
+
+#### Rails
+
+```ruby
+# config/routes.rb
+Rails.application.routes.draw do
+  get '/.well-known/nodeinfo', to: 'node_info#well_known'
+  get '/nodeinfo/2.1',         to: 'node_info#show'
+end
+
+# app/controllers/node_info_controller.rb
+class NodeInfoController < ApplicationController
+  def well_known
+    render json: server.well_known(request.base_url)
+  end
+
+  def show
+    render json: server.to_json
+  end
+
+  private
+
+  def server
+    @server ||= NodeInfo::Server.new do |config|
+      config.software_name            = 'example_app'
+      config.software_version         = Rails.application.config.version
+      config.protocols                = ['activitypub']
+      config.open_registrations       = Rails.application.config.open_registrations
+      config.usage_users              = -> { User.count }
+      config.usage_users_active_month = -> { User.active_last_month.count }
+      config.usage_local_posts        = -> { Post.local.count }
+    end
+  end
+end
+```
+
+#### Hanami
+
+```ruby
+# config/routes.rb
+get '/.well-known/nodeinfo', to: 'node_info.well_known'
+get '/nodeinfo/2.1',         to: 'node_info.show'
+
+# app/actions/node_info/well_known.rb
+module ExampleApp
+  module Actions
+    module NodeInfo
+      class WellKnown < ExampleApp::Action
+        def handle request, response
+          server          = build_server
+          response.format = :json
+          response.body   = server.well_known_json request.base_url
+        end
+
+        private
+
+        def build_server
+          NodeInfo::Server.new do |config|
+            config.software_name    = 'example_app'
+            config.software_version = '1.0.0'
+            config.protocols        = ['activitypub']
+          end
+        end
+      end
+    end
+  end
+end
+```
+
+## Configuration Options
+
+### Server Configuration
+
+| Option | Type | Required | Description |
+|--------|------|----------|-------------|
+| `protocols` | Array | Yes | Supported protocols (e.g., `['activitypub']`) |
+| `software_name` | String | Yes | Name of your software |
+| `software_version` | String | Yes | Version of your software |
+| `software_repository` | String | No | URL to source code repository |
+| `software_homepage` | String | No | URL to software homepage |
+| `services_inbound` | Array | No | Inbound services (e.g., `['atom1.0']`) |
+| `services_outbound` | Array | No | Outbound services (e.g., `['rss2.0']`) |
+| `open_registrations` | Boolean | No | Whether registrations are open (default: `false`) |
+| `usage_users` | Hash/Proc | No | User statistics |
+| `usage_users_active_month` | Integer/Proc | No | Active users in last month |
+| `usage_users_active_halfyear` | Integer/Proc | No | Active users in last 6 months |
+| `usage_local_posts` | Integer/Proc | No | Number of local posts |
+| `usage_local_comments` | Integer/Proc | No | Number of local comments |
+| `metadata` | Hash | No | Custom metadata |
+| `base_url` | String | No | Base URL for well-known response |
+
+## Error Handling
+
+The gem defines several error classes:
+
+```ruby
+NodeInfo::Error           # Base error class
+NodeInfo::DiscoveryError  # Discovery failed
+NodeInfo::FetchError      # Fetching document failed
+NodeInfo::ParseError      # Parsing document failed
+NodeInfo::ValidationError # Validation failed
+NodeInfo::HTTPError       # HTTP request failed
+```
+
+Example error handling:
+
+```ruby
+begin
+  info = client.fetch 'example.com'
+rescue NodeInfo::DiscoveryError => e
+  puts "Could not discover NodeInfo: #{e.message}"
+rescue NodeInfo::FetchError => e
+  puts "Could not fetch NodeInfo: #{e.message}"
+rescue NodeInfo::ParseError => e
+  puts "Could not parse NodeInfo: #{e.message}"
+rescue NodeInfo::Error => e
+  puts "NodeInfo error: #{e.message}"
+end
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies.
+Then, run `rake spec` to run the tests.
+You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`.
+
+### Running Tests
+
+```ruby
+bundle exec rspec
+```
+
+### Running RuboCop
+
+```ruby
+bundle exec rubocop
+```
+
+### Running All Checks
+
+```ruby
+bundle exec rake
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at the
+https://github.com/xoengineering/node_info repo.
+
+## License
+
+The gem is available as open source under the terms of the
+[MIT License](https://opensource.org/licenses/MIT).
+
+## References
+
+- [NodeInfo Specification](https://nodeinfo.diaspora.software/)
+- [FEP-f1d5: NodeInfo in the Fediverse](https://codeberg.org/fediverse/fep/src/branch/main/fep/f1d5/fep-f1d5.md)
+- [ActivityPub](https://www.w3.org/TR/activitypub/)

data/lib/node_info/client.rb

@@ -0,0 +1,111 @@
+require 'http'
+require 'json'
+require 'uri'
+
+module NodeInfo
+  # Client for discovering and fetching NodeInfo from Fediverse servers
+  #
+  # @example Fetch NodeInfo from a server
+  #   client = NodeInfo::Client.new
+  #   info = client.fetch("mastodon.social")
+  #   puts info.software.name
+  class Client
+    WELL_KNOWN_PATH = '/.well-known/nodeinfo'.freeze
+
+    SUPPORTED_SCHEMAS = [
+      'http://nodeinfo.diaspora.software/ns/schema/2.1',
+      'http://nodeinfo.diaspora.software/ns/schema/2.0'
+    ].freeze
+
+    attr_reader :timeout, :follow_redirects
+
+    # Initialize a new client
+    # @param timeout [Integer] HTTP timeout in seconds (default: 10)
+    # @param follow_redirects [Boolean] Whether to follow HTTP redirects (default: true)
+    def initialize timeout: 10, follow_redirects: true
+      @timeout = timeout
+      @follow_redirects = follow_redirects
+    end
+
+    # Fetch NodeInfo from a server
+    # @param domain [String] The domain to fetch from (e.g., "mastodon.social")
+    # @return [NodeInfo::Document]
+    # @raise [NodeInfo::DiscoveryError] If discovery fails
+    # @raise [NodeInfo::FetchError] If fetching fails
+    # @raise [NodeInfo::ParseError] If parsing fails
+    def fetch domain
+      url = discover(domain)
+      fetch_document(url)
+    end
+
+    # Discover NodeInfo URL for a domain
+    # @param domain [String] The domain to discover
+    # @return [String] The NodeInfo document URL
+    # @raise [NodeInfo::DiscoveryError] If discovery fails
+    def discover domain
+      url = normalize_url domain, WELL_KNOWN_PATH
+
+      response = http_client.get url
+
+      raise DiscoveryError, "HTTP #{response.code}" unless response.status.success?
+
+      links = parse_well_known response.body.to_s
+      find_nodeinfo_url links
+    rescue HTTP::Error => e
+      raise DiscoveryError, "HTTP request failed: #{e.message}"
+    end
+
+    # Fetch NodeInfo document from URL
+    # @param url [String] The NodeInfo document URL
+    # @return [NodeInfo::Document]
+    # @raise [NodeInfo::FetchError] If fetching fails
+    def fetch_document url
+      response = http_client.get url
+
+      raise FetchError, "HTTP #{response.code}" unless response.status.success?
+
+      Document.parse response.body.to_s
+    rescue HTTP::Error => e
+      raise FetchError, "HTTP request failed: #{e.message}"
+    end
+
+    private
+
+    def http_client
+      client = HTTP.timeout timeout
+      client = client.follow if follow_redirects
+      client
+    end
+
+    def normalize_url domain, path
+      url  = URI.parse domain
+      url  = URI.parse("https://#{domain}") unless domain.start_with? 'http'
+      host = url.host
+
+      URI::HTTPS.build(host: host, path: path).to_s
+    end
+
+    def parse_well_known body
+      data = JSON.parse body
+      links = data['links']
+
+      raise DiscoveryError, 'No links found in well-known document' unless links
+      raise DiscoveryError, 'Links must be an array' unless links.is_a? Array
+
+      links
+    rescue JSON::ParserError => e
+      raise DiscoveryError, "Invalid JSON in well-known document: #{e.message}"
+    end
+
+    def find_nodeinfo_url links
+      # Try to find a supported schema, preferring 2.1 over 2.0
+      SUPPORTED_SCHEMAS.each do |schema|
+        link = links.find { it['rel'] == schema }
+
+        return link['href'] if link && link['href']
+      end
+
+      raise DiscoveryError, 'No supported NodeInfo schema found'
+    end
+  end
+end

data/lib/node_info/document.rb

@@ -0,0 +1,170 @@
+require 'json'
+
+module NodeInfo
+  # Represents a NodeInfo 2.1 document
+  class Document
+    attr_reader :version, :software, :protocols, :services, :open_registrations, :usage, :metadata
+
+    # Software information
+    class Software
+      attr_reader :name, :version, :repository, :homepage
+
+      def initialize name:, version:, repository: nil, homepage: nil
+        @name       = name
+        @version    = version
+        @repository = repository
+        @homepage   = homepage
+      end
+
+      def to_h
+        {
+          name:       name,
+          version:    version,
+          repository: repository,
+          homepage:   homepage
+        }.compact
+      end
+    end
+
+    # Services information
+    class Services
+      attr_reader :inbound, :outbound
+
+      def initialize inbound: [], outbound: []
+        @inbound  = inbound
+        @outbound = outbound
+      end
+
+      def to_h = { inbound: inbound, outbound: outbound }
+    end
+
+    # Usage statistics
+    class Usage
+      attr_reader :users, :local_posts, :local_comments
+
+      def initialize users: {}, local_posts: nil, local_comments: nil
+        @users = users
+        @local_posts = local_posts
+        @local_comments = local_comments
+      end
+
+      def to_h
+        {
+          users:         users,
+          localPosts:    local_posts,
+          localComments: local_comments
+        }.compact
+      end
+    end
+
+    # Parse a NodeInfo document from JSON
+    # @param json [String, Hash] JSON string or hash
+    # @return [NodeInfo::Document]
+    def self.parse json
+      data = json.is_a?(String) ? JSON.parse(json) : json
+      data = deep_stringify_keys data
+
+      metadata = data['metadata'] || {}
+      metadata = metadata.transform_keys &:to_sym
+
+      new version:            data['version'],
+          software:           parse_software(data['software']),
+          protocols:          data['protocols'],
+          services:           parse_services(data['services']),
+          open_registrations: data['openRegistrations'],
+          usage:              parse_usage(data['usage']),
+          metadata:           metadata
+    rescue JSON::ParserError => e
+      raise ParseError, "Invalid JSON: #{e.message}"
+    rescue StandardError => e
+      raise ParseError, "Failed to parse NodeInfo document: #{e.message}"
+    end
+
+    # Initialize a new NodeInfo document
+    def initialize software:, protocols:, open_registrations: false, metadata: nil, services: nil, usage: nil, version: '2.1'
+      @software  = software
+      @protocols = protocols
+
+      @metadata           = metadata || {}
+      @open_registrations = open_registrations
+      @services           = services || Services.new
+      @usage              = usage    || Usage.new
+      @version            = version
+
+      validate!
+    end
+
+    # Convert to hash representation
+    # @return [Hash]
+    def to_h
+      {
+        version:           version,
+        software:          software.to_h,
+        protocols:         protocols,
+        services:          services.to_h,
+        openRegistrations: open_registrations,
+        usage:             usage.to_h,
+        metadata:          metadata
+      }
+    end
+
+    # Convert to JSON string
+    # @return [String]
+    def to_json(*) = to_h.to_json(*)
+
+    class << self
+      private
+
+      def deep_stringify_keys obj
+        case obj
+        when Hash
+          obj.each_with_object({}) { |(k, v), h| h[k.to_s] = deep_stringify_keys(v) }
+        when Array
+          obj.map { deep_stringify_keys it }
+        else
+          obj
+        end
+      end
+
+      def parse_software data
+        return nil unless data
+
+        Software.new name:       data['name'],
+                     version:    data['version'],
+                     repository: data['repository'],
+                     homepage:   data['homepage']
+      end
+
+      def parse_services data
+        return Services.new unless data
+
+        Services.new inbound:  data['inbound'] || [],
+                     outbound: data['outbound'] || []
+      end
+
+      def parse_usage data
+        return Usage.new unless data
+
+        users = data['users'] || {}
+        users = users.transform_keys(&:to_sym)
+
+        Usage.new users:          users,
+                  local_posts:    data['localPosts'],
+                  local_comments: data['localComments']
+      end
+    end
+
+    private
+
+    def validate!
+      raise ValidationError, 'version is required'                 if version.nil? || version.empty?
+      raise ValidationError, 'software is required'                if software.nil?
+      raise ValidationError, 'software.name is required'           if software.name.nil? || software.name.empty?
+      raise ValidationError, 'software.version is required'        if software.version.nil? || software.version.empty?
+      raise ValidationError, 'protocols is required'               if protocols.nil?
+
+      raise ValidationError, 'protocols must be an array'          unless protocols.is_a?(Array)
+      raise ValidationError, 'openRegistrations must be a boolean' unless [true, false].include?(open_registrations)
+    end
+  end
+end

data/lib/node_info/errors.rb

@@ -0,0 +1,26 @@
+module NodeInfo
+  # Base error class for all NodeInfo errors
+  class Error < StandardError; end
+
+  # Raised when NodeInfo discovery fails
+  class DiscoveryError < Error; end
+
+  # Raised when fetching NodeInfo document fails
+  class FetchError < Error; end
+
+  # Raised when parsing NodeInfo document fails
+  class ParseError < Error; end
+
+  # Raised when validating NodeInfo document fails
+  class ValidationError < Error; end
+
+  # Raised when HTTP request fails
+  class HTTPError < Error
+    attr_reader :response
+
+    def initialize message, response = nil
+      super(message)
+      @response = response
+    end
+  end
+end

data/lib/node_info/server.rb

@@ -0,0 +1,172 @@
+require 'json'
+
+module NodeInfo
+  # Server for generating NodeInfo documents and well-known responses
+  #
+  # @example Basic usage
+  #   server = NodeInfo::Server.new do |config|
+  #     config.software_name = "myapp"
+  #     config.software_version = "1.0.0"
+  #     config.protocols = ["activitypub"]
+  #   end
+  #   server.to_json # => NodeInfo document
+  #
+  # @example With dynamic usage stats
+  #   server = NodeInfo::Server.new do |config|
+  #     config.software_name = "myapp"
+  #     config.software_version = "1.0.0"
+  #     config.protocols = ["activitypub"]
+  #     config.usage_users = -> { User.count }
+  #     config.usage_users_active_month = -> { User.active.count }
+  #   end
+  class Server
+    # Configuration for NodeInfo server
+    class Config
+      attr_accessor :base_url, :metadata, :open_registrations, :protocols,
+                    :services_inbound, :services_outbound,
+                    :software_homepage, :software_version, :software_name, :software_repository,
+                    :usage_local_comments, :usage_local_posts,
+                    :usage_users, :usage_users_active_halfyear, :usage_users_active_month
+
+      def initialize
+        @metadata           = {}
+        @open_registrations = false
+        @protocols          = []
+        @services_inbound   = []
+        @services_outbound  = []
+        @usage_users        = {}
+      end
+
+      # Get usage users hash, evaluating procs if necessary
+      def users_hash
+        users = usage_users.is_a?(Proc) ? usage_users.call : usage_users
+
+        if users.is_a? Hash
+          result = {}
+          result[:total]          = evaluate_value(users[:total]) if users[:total]
+          result[:activeMonth]    = evaluate_value(users[:activeMonth]    || usage_users_active_month)
+          result[:activeHalfyear] = evaluate_value(users[:activeHalfyear] || usage_users_active_halfyear)
+        else
+          result                  = { total: evaluate_value(users) }
+          result[:activeMonth]    = evaluate_value(usage_users_active_month)
+          result[:activeHalfyear] = evaluate_value(usage_users_active_halfyear)
+        end
+
+        result.compact
+      end
+
+      private
+
+      def evaluate_value value
+        value.is_a?(Proc) ? value.call : value
+      end
+    end
+
+    attr_reader :config
+
+    # Initialize a new server
+    # @yield [config] Configuration block
+    def initialize
+      @config = Config.new
+      yield(config) if block_given?
+      validate_config!
+    end
+
+    # Generate the well-known nodeinfo response
+    # @param base_url [String] Base URL of the server (e.g., "https://example.com")
+    # @return [Hash] Well-known response
+    def well_known base_url = nil
+      url = base_url || config.base_url
+      raise ArgumentError, 'base_url is required' unless url
+
+      {
+        links: [
+          {
+            rel:  'http://nodeinfo.diaspora.software/ns/schema/2.1',
+            href: "#{url}/nodeinfo/2.1"
+          }
+        ]
+      }
+    end
+
+    # Generate the well-known nodeinfo response as JSON
+    # @param base_url [String] Base URL of the server
+    # @return [String] JSON string
+    def well_known_json base_url = nil
+      well_known(base_url).to_json
+    end
+
+    # Generate the NodeInfo document
+    # @return [NodeInfo::Document]
+    def document
+      Document.new version:            '2.1',
+                   software:           build_software,
+                   protocols:          config.protocols,
+                   services:           build_services,
+                   open_registrations: config.open_registrations,
+                   usage:              build_usage,
+                   metadata:           config.metadata
+    end
+
+    # Generate the NodeInfo document as a hash
+    # @return [Hash]
+    def to_h
+      document.to_h
+    end
+
+    # Generate the NodeInfo document as JSON
+    # @return [String]
+    def to_json(*)
+      document.to_json(*)
+    end
+
+    private
+
+    def validate_config!
+      raise ValidationError, 'software_name is required'    unless config.software_name
+      raise ValidationError, 'software_version is required' unless config.software_version
+      raise ValidationError, 'protocols is required'        unless config.protocols
+      raise ValidationError, 'protocols must be an array'   unless config.protocols.is_a?(Array)
+    end
+
+    def build_software
+      Document::Software.new(
+        name:       config.software_name,
+        version:    config.software_version,
+        repository: config.software_repository,
+        homepage:   config.software_homepage
+      )
+    end
+
+    def build_services
+      Document::Services.new(
+        inbound:  config.services_inbound,
+        outbound: config.services_outbound
+      )
+    end
+
+    def build_usage
+      usage_hash = {
+        users: config.users_hash
+      }
+
+      if config.usage_local_posts
+        usage_hash[:local_posts] = if config.usage_local_posts.is_a?(Proc)
+                                     config.usage_local_posts.call
+                                   else
+                                     config.usage_local_posts
+                                   end
+      end
+
+      if config.usage_local_comments
+        usage_hash[:local_comments] = if config.usage_local_comments.is_a?(Proc)
+                                        config.usage_local_comments.call
+                                      else
+                                        config.usage_local_comments
+                                      end
+      end
+
+      Document::Usage.new(**usage_hash)
+    end
+  end
+end

data/lib/node_info/version.rb

@@ -0,0 +1,3 @@
+module NodeInfo
+  VERSION = '0.1.0'.freeze
+end

data/lib/node_info.rb

@@ -0,0 +1,37 @@
+require_relative 'node_info/version'
+require_relative 'node_info/client'
+require_relative 'node_info/server'
+require_relative 'node_info/document'
+require_relative 'node_info/errors'
+
+# NodeInfo protocol implementation for the Fediverse
+#
+# This gem provides both client and server functionality for the NodeInfo protocol
+# as specified in FEP-f1d5. NodeInfo is a standardized way for Fediverse servers
+# to expose metadata about themselves.
+#
+# @example Client usage
+#   client = NodeInfo::Client.new
+#   info = client.fetch("mastodon.social")
+#   puts info.software.name # => "mastodon"
+#
+# @example Server usage
+#   server = NodeInfo::Server.new do |config|
+#     config.software_name = "myapp"
+#     config.software_version = "1.0.0"
+#     config.protocols = ["activitypub"]
+#     config.open_registrations = true
+#   end
+#   json = server.to_json
+module NodeInfo
+  class << self
+    # Create a new NodeInfo client
+    # @return [NodeInfo::Client]
+    def client = Client.new
+
+    # Create a new NodeInfo server
+    # @yield [config] Configuration block
+    # @return [NodeInfo::Server]
+    def server(&) = Server.new(&)
+  end
+end

metadata

@@ -0,0 +1,67 @@
+--- !ruby/object:Gem::Specification
+name: node_info
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Shane Becker
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: http
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+description: |
+  A pure Ruby implementation of the NodeInfo protocol (FEP-f1d5) for the Fediverse,
+  providing both client and server functionality.
+email:
+- veganstraightedge@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- README.md
+- lib/node_info.rb
+- lib/node_info/client.rb
+- lib/node_info/document.rb
+- lib/node_info/errors.rb
+- lib/node_info/server.rb
+- lib/node_info/version.rb
+homepage: https://github.com/xoengineering/node_info
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/xoengineering/node_info
+  changelog_uri: https://github.com/xoengineering/node_info/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 4.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.3
+specification_version: 4
+summary: NodeInfo protocol client and server implementation
+test_files: []