ruby-net-text 0.0.8 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 948586ccc73c2f1c60ae689e9f9a04bdfe7598affd2300501f8490a511f582c3
-  data.tar.gz: 0ae1eb4e3b191ffe5d506f15d981d7cb325479f9cf7fafcc9f7de63e7f13a8fe
+  metadata.gz: 2610c775fb8178c5c035a7ffbb9176ba679a15fcd061fed7e192b3d83b609727
+  data.tar.gz: 386863cda1e5682d05bc75a52da55ae4d972393db7efa38fed7d259b44f9e717
 SHA512:
-  metadata.gz: 5bae93436e2d8b7985fe39e26d3bf067713e4fbf46759bc91b641bd6200e9ea8dab676868c8f89a6e89679986ceb2c96f54c7db591e28494e18d7ac5ee0a5343
-  data.tar.gz: 55621ad4d9bf7ea94ab1529e85acac2c279d097234eb85156027ef91fcca466bf90ab8d2cb0e3a312032fdb0248d198da5c8f8cdf11e436e2df88e5d7977758f
+  metadata.gz: 8c7663972f81f9f93e02bf76bccfaa1b158b4034259617e94856d27fb63aa5368def164135cea3318c355e3e137ae0c6b852b96194c52db9180aecd318a8d3e1
+  data.tar.gz: 61bff20043c1866c3075312a87f9a68dc7d7aa7fd869d8962672dc2ce6eeed9ad065d6ca0bc8330bc94a41fa041933a7bf0da20c0871826d805a0febf2d8dcb2

data/README.md

@@ -1,19 +1,47 @@
-# Gemini, Gopher, and Finger support for Net::* and URI::*
+# Finger, Gemini, Gopher and Nex support for Net::* and URI::*
 
 [![Support using Liberapay](https://img.shields.io/badge/Liberapay-Support_me-yellow?logo=liberapay)](https://liberapay.com/milouse/donate)
 [![Support using Flattr](https://img.shields.io/badge/Flattr-Support_me-brightgreen?logo=flattr)](https://flattr.com/@milouse)
 [![Support using Paypal](https://img.shields.io/badge/Paypal-Support_me-00457C?logo=paypal&labelColor=lightgray)](https://paypal.me/milouse)
 
 [![Gem](https://img.shields.io/gem/v/ruby-net-text)](https://rubygems.org/gems/ruby-net-text)
-[![Documentation](https://img.shields.io/badge/Documentation-ruby--net--text-CC342D?logo=rubygems)](https://www.rubydoc.info/gems/ruby-net-text/Net/Gemini)
+[![Documentation](https://img.shields.io/badge/Documentation-ruby--net--text-CC342D?logo=rubygems)](https://www.rubydoc.info/gems/ruby-net-text/)
 
 This project aims to add connectors to well known internet text protocols
 through the standard `Net::*` and `URI::*` ruby module namespaces.
 
+## News
+
+### Version 0.0.9 gemini breaking changes
+
+This new version changes the Gemini namespace. Everything is now under the
+same `Net::Gemini` namespace. If you just used this gem as per the
+documentation, nothing changes for you. However, if you were using some hidden
+part of the Gemini API, you will probably have to make some changes.
+
+Here are all the changes:
+
+| Old names              | New names                                                                |
+|------------------------|--------------------------------------------------------------------------|
+| Net::GeminiRequest     | Net::Gemini::Request (still 'net/gemini/request')                        |
+| Net::GeminiBadRequest  | Net::Gemini::BadRequest (require 'net/gemini/error')                     |
+| Net::GeminiResponse    | Net::Gemini::Response (still 'net/gemini/response')                      |
+| Net::GeminiBadResponse | Net::Gemini::BadResponse (require 'net/gemini/error')                    |
+| Net::GeminiError       | Net::Gemini::Error (require 'net/gemini/error')                          |
+| Net::Gemini.new        | Net::Gemini::Client.new (directly required as part of 'net/gemini')      |
+| Gemini::ReflowText     | Net::Text::Reflow (no more expected to be included, but directly called) |
+| Gemini::GmiParser      | - (directly integrated into Net::Gemini::Response)                       |
+| Gemini::SSL            | - (directly integrated into Net::Gemini::Client)                         |
+
 ## Documentation
 
 The code is self-documented and you can browse it on rubydoc.info:
 
+### Finger
+
+- [URI::Finger](https://www.rubydoc.info/gems/ruby-net-text/URI/Finger)
+- [Net::Finger](https://www.rubydoc.info/gems/ruby-net-text/Net/Finger)
+
 ### Gemini
 
 - [URI::Gemini](https://www.rubydoc.info/gems/ruby-net-text/URI/Gemini)
@@ -24,16 +52,16 @@ The code is self-documented and you can browse it on rubydoc.info:
 - [URI::Gopher](https://www.rubydoc.info/gems/ruby-net-text/URI/Gopher)
 - [Net::Gopher](https://www.rubydoc.info/gems/ruby-net-text/Net/Gopher)
 
-### Finger
+### Nex
 
-- [URI::Finger](https://www.rubydoc.info/gems/ruby-net-text/URI/Finger)
-- [Net::Finger](https://www.rubydoc.info/gems/ruby-net-text/Net/Finger)
+- [URI::Nex](https://www.rubydoc.info/gems/ruby-net-text/URI/Nex)
+- [Net::Nex](https://www.rubydoc.info/gems/ruby-net-text/Net/Nex)
 
 ## Helpers
 
 This repository also includes 2 little helpers:
 
-- `bin/heraut`: a toy client for Gemini, Gopher and Finger. Give it a URI and
-  it will output the remote file.
+- `bin/heraut`: a toy client for Finger, Gemini, Gopher and Nex. Give it a URI
+  and it will output the remote file.
 - `bin/test_thread.rb`: a toy performance test script to run against a Gemini
   server

data/lib/net/finger.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 require_relative '../uri/finger'
-require_relative 'generic'
+require_relative 'text/generic'
 
 module Net
   # == A Finger client API for Ruby.
@@ -28,9 +28,7 @@ module Net
   #   uri = URI('finger://skyjake.fi/jaakko')
   #   Net::Finger.get(uri) # => String
   #
-  class Finger
-    extend TextGeneric
-
+  class Finger < Text::Generic
     def self.get(string_or_uri)
       uri = build_uri string_or_uri, URI::Finger
       request uri, uri.name.to_s

data/lib/net/gemini/client/ssl.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Net
+  module Gemini
+    # Reopen Client class to add specific private method to handle SSL
+    # connection
+    class Client
+      private
+
+      def ssl_check_existing(new_cert, cert_file)
+        raw = File.read cert_file
+        saved_one = OpenSSL::X509::Certificate.new raw
+        return true if saved_one == new_cert
+
+        # TODO: offer some kind of recuperation
+        warn "#{cert_file} does not match the current host cert!"
+        false
+      end
+
+      def ssl_verify_cb(cert)
+        identity_check = OpenSSL::SSL.verify_certificate_identity(cert, @host)
+        return false unless identity_check
+
+        cert_file = File.expand_path("#{@certs_path}/#{@host}.pem")
+        return ssl_check_existing(cert, cert_file) if File.exist?(cert_file)
+
+        FileUtils.mkdir_p(File.expand_path(@certs_path))
+        File.open(cert_file, 'wb') { |f| f.print cert.to_pem }
+        true
+      end
+
+      def ssl_context
+        ssl_context = OpenSSL::SSL::SSLContext.new
+        ssl_context.set_params(
+          verify_mode: OpenSSL::SSL::VERIFY_PEER,
+          min_version: OpenSSL::SSL::TLS1_2_VERSION,
+          ca_file: '/etc/ssl/certs/ca-certificates.crt',
+          verify_hostname: true
+        )
+        ssl_context.verify_callback = lambda do |preverify_ok, store_context|
+          return true if preverify_ok
+
+          ssl_verify_cb store_context.current_cert
+        end
+        ssl_context
+      end
+
+      def init_sockets
+        socket = TCPSocket.new(@host, @port)
+        @ssl_socket = OpenSSL::SSL::SSLSocket.new(socket, ssl_context)
+        # Close underlying TCP socket with SSL socket
+        @ssl_socket.sync_close = true
+        @ssl_socket.hostname = @host # SNI
+        @ssl_socket.connect
+      end
+
+      # Closes the SSL and TCP connections.
+      def finish
+        @ssl_socket.close
+      end
+    end
+  end
+end

data/lib/net/gemini/client.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require_relative 'error'
+require_relative 'request'
+require_relative 'response'
+require_relative '../text/generic'
+
+module Net
+  module Gemini # rubocop:disable Style/Documentation
+    # An example client to fetch resources hosted on Gemini network.
+    class Client
+      attr_writer :certs_path
+
+      def initialize(host, port)
+        @host = host
+        @port = port
+        @certs_path = '~/.cache/gemini/certs'
+      end
+
+      # This method can raise an OpenSSL::SSL::SSLError
+      def request!(uri)
+        init_sockets
+        req = Request.new uri
+        req.write @ssl_socket
+        res = Response.read_new(@ssl_socket)
+        res.uri = uri
+        res.reading_body(@ssl_socket)
+      end
+
+      def request(uri)
+        request! uri
+      rescue OpenSSL::SSL::SSLError => e
+        msg = format(
+          'SSLError: %<cause>s',
+          cause: e.message.sub(/.*state=error: (.+)\Z/, '\1')
+        )
+        Response.new('59', msg)
+      ensure
+        # Stop remaining connection, even if they should be already cut
+        # by the server
+        finish
+      end
+
+      def fetch(uri, limit = 5)
+        raise Error, 'Too many Gemini redirects' if limit.zero?
+
+        r = request(uri)
+        return r unless r.status[0] == '3'
+
+        begin
+          uri = handle_redirect(r)
+        rescue ArgumentError, URI::InvalidURIError
+          return r
+        end
+        warn "Redirect to #{uri}" if $VERBOSE
+        fetch(uri, limit - 1)
+      end
+
+      private
+
+      def handle_redirect(response)
+        uri = response.uri
+        old_url = uri.to_s
+        new_uri = URI(response.meta)
+        uri.merge!(new_uri)
+        raise Error, "Redirect loop on #{uri}" if uri.to_s == old_url
+
+        @host = uri.host
+        @port = uri.port
+        uri
+      end
+    end
+
+    def self.start(host_or_uri, port = nil, &block)
+      if host_or_uri.is_a? URI::Gemini
+        host = host_or_uri.host
+        port = host_or_uri.port
+      else
+        host = host_or_uri
+      end
+      gem = Client.new(host, port)
+      return gem unless block
+
+      yield gem
+    end
+
+    def self.get_response(uri)
+      start(uri.host, uri.port) { |gem| gem.fetch(uri) }
+    end
+
+    def self.get(string_or_uri)
+      uri = Net::Text::Generic.build_uri string_or_uri, URI::Gemini
+      get_response(uri).body
+    end
+  end
+end
+
+require_relative 'client/ssl'

data/lib/net/gemini/error.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Net
+  module Gemini
+    class Error < StandardError; end
+    class BadRequest < Error; end
+    class BadResponse < Error; end
+  end
+end

data/lib/net/gemini/request.rb

@@ -2,48 +2,52 @@
 
 require 'English'
 
-require 'uri/gemini'
+require_relative '../../uri/gemini'
+require_relative 'error'
 
 module Net
-  class GeminiBadRequest < StandardError; end
-
-  #
-  # The syntax of Gemini Requests are defined in the Gemini
-  # specification, section 2.
-  #
-  # @see https://gemini.circumlunar.space/docs/specification.html
-  #
-  class GeminiRequest
-    attr_reader :uri
-
-    def initialize(uri_or_str)
-      # In any case, make some sanity check over this uri-like think
-      url = uri_or_str.to_s
-      if url.length > 1024
-        raise GeminiBadRequest, "Request too long: #{url.dump}"
+  module Gemini
+    class BadRequest < Error; end
+
+    #
+    # The syntax of Gemini Requests are defined in the Gemini
+    # specification, section 2.
+    #
+    # @see https://geminiprotocol.net/docs/protocol-specification.html
+    #
+    class Request
+      attr_reader :uri
+
+      def initialize(uri_or_str)
+        # In any case, make some sanity check over this uri-like think
+        url = uri_or_str.to_s
+        raise BadRequest, "Request too long: #{url.dump}" if url.length > 1024
+
+        @uri = URI(url)
+        return if uri.is_a? URI::Gemini
+
+        raise BadRequest, "Not a Gemini URI: #{url.dump}"
       end
-      @uri = URI(url)
-      return if uri.is_a? URI::Gemini
-      raise GeminiBadRequest, "Not a Gemini URI: #{url.dump}"
-    end
 
-    def path
-      @uri.path
-    end
+      def path
+        @uri.path
+      end
 
-    def write(sock)
-      sock.puts "#{@uri}\r\n"
-    end
+      def write(sock)
+        sock.puts "#{@uri}\r\n"
+      end
 
-    class << self
-      def read_new(sock)
-        # Read up to 1026 bytes:
-        # - 1024 bytes max for the URL
-        # - 2 bytes for <CR><LF>
-        str = sock.gets($INPUT_RECORD_SEPARATOR, 1026)
-        m = /\A(.*)\r\n\z/.match(str)
-        raise GeminiBadRequest, "Malformed request: #{str&.dump}" if m.nil?
-        new(m[1])
+      class << self
+        def read_new(sock)
+          # Read up to 1026 bytes:
+          # - 1024 bytes max for the URL
+          # - 2 bytes for <CR><LF>
+          str = sock.gets($INPUT_RECORD_SEPARATOR, 1026)
+          m = /\A(.*)\r\n\z/.match(str)
+          raise BadRequest, "Malformed request: #{str&.dump}" if m.nil?
+
+          new(m[1])
+        end
       end
     end
   end

data/lib/net/gemini/response/parser.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Net
+  module Gemini
+    # Reopen Response class to add specific private method to parse
+    # text/gemini documents.
+    class Response
+      private
+
+      def received_mime(raw_meta)
+        meta_data = raw_meta.map { |m| m.split('=') }
+        mime = { lang: nil, charset: 'utf-8', format: nil }
+        new_mime = meta_data.filter_map do |opt|
+          key = opt[0].downcase.to_sym
+          next unless mime.has_key? key
+
+          [key, opt[1].downcase]
+        end
+        mime.merge new_mime.to_h
+      end
+
+      def parse_meta
+        header = { status: @status, meta: @meta, mimetype: nil }
+        return header unless body_permitted?
+
+        raw_meta = meta.split(';').map(&:strip)
+        header[:mimetype] = raw_meta.shift
+        return header unless raw_meta.any?
+
+        header.merge received_mime(raw_meta)
+      end
+
+      def parse_preformatted_block(line, buf)
+        cur_block = { meta: line[3..].chomp, content: '' }
+        while (line = buf.gets)
+          if line.start_with?('```')
+            @preformatted_blocks << cur_block
+            break
+          end
+          cur_block[:content] += line
+        end
+      end
+
+      def parse_link(line)
+        m = line.strip.match(/\A=>\s*([^\s]+)(?:\s*(.+))?\z/)
+        return if m.nil?
+
+        begin
+          uri = URI(m[1])
+        rescue URI::InvalidURIError
+          return
+        end
+        uri = @uri.merge(uri) if @uri && uri.is_a?(URI::Generic)
+        @links << { uri: uri, label: m[2]&.chomp }
+      end
+
+      def parse_body
+        buf = StringIO.new(@body)
+        while (line = buf.gets)
+          if line.start_with?('```')
+            parse_preformatted_block(line, buf)
+          elsif line.start_with?('=>')
+            parse_link(line)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/net/gemini/response.rb

@@ -3,103 +3,118 @@
 require 'English'
 require 'stringio'
 
-require_relative 'gmi_parser'
-require_relative 'reflow_text'
+require_relative 'error'
+require_relative '../text/reflow'
 
 module Net
-  class GeminiBadResponse < StandardError; end
-
-  #
-  # The syntax of Gemini Responses are defined in the Gemini
-  # specification, section 3.
-  #
-  # @see https://gemini.circumlunar.space/docs/specification.html
-  #
-  class GeminiResponse
-    # The Gemini response <STATUS> string.
+  module Gemini
     #
-    # For example, '20'.
-    attr_reader :status
-
-    # The Gemini response <META> message sent by the server as a string.
+    # The syntax of Gemini Responses are defined in the Gemini
+    # specification, section 3.
     #
-    # For example, 'text/gemini'.
-    attr_reader :meta
-
-    # The Gemini response <META> as a qualified Hash.
-    attr_reader :header
-
-    # The Gemini response main content as a string.
-    attr_writer :body
-
-    # The URI related to this response as an URI object.
-    attr_accessor :uri
-
-    # All links found on a Gemini response of MIME text/gemini, as an
-    #   array.
-    attr_reader :links
-
-    def initialize(status = nil, meta = nil)
-      @status = status
-      @meta = meta
-      @header = parse_meta
-      @uri = nil
-      @body = nil
-      @links = []
-      @preformatted_blocks = []
-    end
+    # @see https://geminiprotocol.net/docs/protocol-specification.html
+    #
+    # See {Net::Gemini} documentation to see how to interract with a
+    # Response.
+    #
+    class Response
+      # @return [String] The Gemini response <STATUS> string.
+      # @example '20'
+      attr_reader :status
+
+      # @return [String] The Gemini response <META> message sent by the server.
+      # @example 'text/gemini'
+      attr_reader :meta
+
+      # @return [Hash] The Gemini response <META>.
+      attr_reader :header
+
+      # The Gemini response main content as a string.
+      attr_writer :body
+
+      # The URI related to this response as an URI object.
+      attr_accessor :uri
+
+      # @return [Array<String>] All links found on a Gemini response of MIME
+      #   text/gemini
+      attr_reader :links
+
+      def initialize(status = nil, meta = nil)
+        @status = status
+        @meta = meta
+        @header = parse_meta
+        @uri = nil
+        @body = nil
+        @links = []
+        @preformatted_blocks = []
+      end
 
-    def body_permitted?
-      @status && @status[0] == '2'
-    end
+      def body_permitted?
+        @status && @status[0] == '2'
+      end
+
+      def reading_body(sock)
+        return self unless body_permitted?
 
-    def reading_body(sock)
-      return self unless body_permitted?
-      raw_body = []
-      while (line = sock.gets)
-        raw_body << line
+        raw_body = []
+        sock.each_line { raw_body << _1 }
+        @body = encode_body(raw_body.join)
+        return self unless @header[:mimetype] == 'text/gemini'
+
+        parse_body
+        self
       end
-      @body = encode_body(raw_body.join)
-      return self unless @header[:mimetype] == 'text/gemini'
-      parse_body
-      self
-    end
 
-    def body(flowed: nil)
-      return '' if @body.nil? # Maybe not ready?
-      return @body if flowed.nil? || @header[:format] == 'fixed'
-      reformat_body(flowed)
-    end
+      # Return the response body (i.e. the requested document content).
+      #
+      # @param reflow_at [Integer] The column at which body content must be
+      #   reflowed. Default is -1, which means "do not reflow".
+      # @return [String] the body content
+      def body(reflow_at: -1)
+        return '' if @body.nil? # Maybe not ready?
+
+        unless reflow_at.is_a? Integer
+          raise(
+            ArgumentError, "reflow_at must be Integer, #{reflow_at.class} given"
+          )
+        end
+
+        return @body if reflow_at <= 0 || @header[:format] == 'fixed'
 
-    class << self
-      def read_new(sock)
-        # Read up to 1029 bytes:
-        # - 3 bytes for code and space separator
-        # - 1024 bytes max for the message
-        # - 2 bytes for <CR><LF>
-        str = sock.gets($INPUT_RECORD_SEPARATOR, 1029)
-        m = /\A([1-6]\d) (.*)\r\n\z/.match(str)
-        raise GeminiBadResponse, "wrong status line: #{str.dump}" if m.nil?
-        new(*m.captures)
+        Net::Text::Reflow.format_body(@body, reflow_at)
       end
-    end
 
-    private
+      class << self
+        def read_new(sock)
+          # Read up to 1029 bytes:
+          # - 3 bytes for code and space separator
+          # - 1024 bytes max for the message
+          # - 2 bytes for <CR><LF>
+          str = sock.gets($INPUT_RECORD_SEPARATOR, 1029)
+          m = /\A([1-6]\d) (.*)\r\n\z/.match(str)
+          raise BadResponse, "wrong status line: #{str.dump}" if m.nil?
+
+          new(*m.captures)
+        end
+      end
 
-    def encode_body(body)
-      return body unless @header[:mimetype].start_with?('text/')
-      if @header[:charset] && @header[:charset] != 'utf-8'
-        # If body use another charset than utf-8, we need first to
-        # declare the raw byte string as using this chasret
-        body.force_encoding(@header[:charset])
-        # Then we can safely try to convert it to utf-8
-        return body.encode('utf-8')
+      private
+
+      def encode_body(body)
+        return body unless @header[:mimetype].start_with?('text/')
+
+        if @header[:charset] && @header[:charset] != 'utf-8'
+          # If body use another charset than utf-8, we need first to
+          # declare the raw byte string as using this chasret
+          body.force_encoding(@header[:charset])
+          # Then we can safely try to convert it to utf-8
+          return body.encode('utf-8')
+        end
+        # Just declare that the body uses utf-8
+        body.force_encoding('utf-8')
       end
-      # Just declare that the body uses utf-8
-      body.force_encoding('utf-8')
     end
-
-    include ::Gemini::GmiParser
-    include ::Gemini::ReflowText
   end
 end
+
+require_relative 'response/parser'

data/lib/net/gemini.rb

@@ -6,19 +6,12 @@ require 'socket'
 require 'openssl'
 require 'fileutils'
 
-require 'uri/gemini'
-require_relative 'gemini/request'
-require_relative 'gemini/response'
-require_relative 'gemini/ssl'
-
 module Net
-  class GeminiError < StandardError; end
-
   # == A Gemini client API for Ruby.
   #
   # Net::Gemini provides a library which can be used to build Gemini
   # user-agents.
-  # @see https://gemini.circumlunar.space/docs/specification.html
+  # @see gemini://geminiprotocol.net/docs/specification.gmi
   #
   # Net::Gemini is designed to work closely with URI.
   #
@@ -36,8 +29,7 @@ module Net
   #
   # === GET by URI
   #
-  #   uri = URI('gemini://gemini.circumlunar.space/')
-  #   Net::Gemini.get(uri) # => String
+  #   Net::Gemini.get('gemini://gemini.circumlunar.space/') # => String
   #
   # === GET with Dynamic Parameters
   #
@@ -66,12 +58,12 @@ module Net
   #
   #   # Body
   #   puts res.body if res.body_permitted?
-  #   puts res.body(flowed: 85)
+  #   puts res.body(reflow_at: 85)
   #
   # === Following Redirection
   #
-  # The {#fetch} method, contrary to the {#request} one will try to
-  # automatically resolves redirection, leading you to the final
+  # The {Client#fetch} method, contrary to the {Client#request} one will try
+  # to automatically resolves redirection, leading you to the final
   # destination.
   #
   #   u = URI('gemini://exemple.com/redirect')
@@ -88,82 +80,7 @@ module Net
   #   puts "#{res.status} - #{res.meta}" # => '20 - text/gemini;'
   #   puts res.uri.to_s                  # => 'gemini://exemple.com/final/dest'
   #
-  class Gemini
-    attr_writer :certs_path
-
-    def initialize(host, port)
-      @host = host
-      @port = port
-      @certs_path = '~/.cache/gemini/certs'
-    end
-
-    def request(uri)
-      init_sockets
-      req = GeminiRequest.new uri
-      req.write @ssl_socket
-      res = GeminiResponse.read_new(@ssl_socket)
-      res.uri = uri
-      res.reading_body(@ssl_socket)
-    rescue OpenSSL::SSL::SSLError => e
-      msg = format(
-        'SSLError: %<cause>s',
-        cause: e.message.sub(/.*state=error: (.+)\Z/, '\1')
-      )
-      GeminiResponse.new('59', msg)
-    ensure
-      # Stop remaining connection, even if they should be already cut
-      # by the server
-      finish
-    end
-
-    def fetch(uri, limit = 5)
-      raise GeminiError, 'Too many Gemini redirects' if limit.zero?
-      r = request(uri)
-      return r unless r.status[0] == '3'
-      begin
-        uri = handle_redirect(r)
-      rescue ArgumentError, URI::InvalidURIError
-        return r
-      end
-      warn "Redirect to #{uri}" if $VERBOSE
-      fetch(uri, limit - 1)
-    end
-
-    class << self
-      def start(host_or_uri, port = nil)
-        if host_or_uri.is_a? URI::Gemini
-          host = host_or_uri.host
-          port = host_or_uri.port
-        else
-          host = host_or_uri
-        end
-        gem = new(host, port)
-        return yield(gem) if block_given?
-        gem
-      end
-
-      def get_response(uri)
-        start(uri.host, uri.port) { |gem| gem.fetch(uri) }
-      end
-
-      def get(uri)
-        get_response(uri).body
-      end
-    end
-
-    private
-
-    def handle_redirect(response)
-      uri = response.uri
-      old_url = uri.to_s
-      new_uri = URI(response.meta)
-      uri.merge!(new_uri)
-      raise GeminiError, "Redirect loop on #{uri}" if uri.to_s == old_url
-      @host = uri.host
-      @port = uri.port
-      uri
-    end
-
-    include ::Gemini::SSL
-  end
+  module Gemini; end
 end
+
+require_relative 'gemini/client'

data/lib/net/gopher.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 require_relative '../uri/gopher'
-require_relative 'generic'
+require_relative 'text/generic'
 
 module Net
   # == A Gopher client API for Ruby.
@@ -28,9 +28,7 @@ module Net
   #   uri = URI('gopher://thelambdalab.xyz/1/projects/elpher/')
   #   Net::Gopher.get(uri) # => String
   #
-  class Gopher
-    extend TextGeneric
-
+  class Gopher < Text::Generic
     def self.get(string_or_uri)
       uri = build_uri string_or_uri, URI::Gopher
       request uri, "#{uri.selector}\r\n"

data/lib/net/nex.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative '../uri/nex'
+require_relative 'text/generic'
+
+module Net
+  # == A Nex client API for Ruby.
+  #
+  # Net::Nex provides a library which can be used to build Nex
+  # user-agents.
+  #
+  # Net::Nex is designed to work closely with URI.
+  #
+  # == Simple Examples
+  #
+  # All examples assume you have loaded Net::Nex with:
+  #
+  #   require 'net/nex'
+  #
+  # This will also require 'uri' so you don't need to require it
+  # separately.
+  #
+  # The Net::Nex methods in the following section do not persist
+  # connections.
+  #
+  # === GET by URI
+  #
+  #   uri = URI('nex://nightfall.city/nex/info/')
+  #   Net::Nex.get(uri) # => String
+  #
+  class Nex < Text::Generic
+    def self.get(string_or_uri)
+      uri = build_uri string_or_uri, URI::Nex
+      request uri, "#{uri.path}\r\n"
+    end
+  end
+end

data/lib/net/text/generic.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'socket'
+
+module Net
+  module Text
+    # Generic interface to be used by specific network protocol implementation.
+    class Generic
+      def self.request(uri, query)
+        sock = TCPSocket.new(uri.host, uri.port)
+        sock.puts query
+        sock.read
+      ensure
+        # Stop remaining connection, even if they should be already cut
+        # by the server
+        sock&.close
+      end
+
+      def self.build_uri(string_or_uri, uri_class)
+        string_or_uri = URI(string_or_uri) if string_or_uri.is_a?(String)
+        return string_or_uri if string_or_uri.is_a?(uri_class)
+
+        raise ArgumentError, "uri is not a String, nor an #{uri_class.name}"
+      end
+    end
+  end
+end

data/lib/net/text/reflow.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Net
+  module Text
+    # Contains helper methods to correctly display texts with long lines.
+    #
+    # This module expect given text to be Gemtext inspired (i.e. links
+    # prefixed with => and ``` delimitting code blocks).
+    module Reflow
+      def self.reflow_line_prefix(line)
+        m = line.match(/\A([*#>]+ )/)
+        return '' unless m
+        # Each quote line should begin with the quote mark
+        return m[1] if m[1].start_with?('>')
+
+        ' ' * m[1].length
+      end
+
+      def self.reflow_text_line(line, mono_block_open, length)
+        line.strip!
+        if mono_block_open || line.start_with?('=>') || line.length < length
+          return [line]
+        end
+
+        output = []
+        prefix = reflow_line_prefix(line)
+        limit_chars = ['-', '­', ' '].freeze
+        while line.length > length
+          cut_line = line[0...length]
+          cut_index = limit_chars.map { cut_line.rindex(_1) || -1 }.max
+          break if cut_index.zero? # Better do nothing for now
+
+          output << line[0...cut_index]
+          line = prefix + line[cut_index + 1..]
+        end
+        output << line
+      end
+
+      def self.format_body(body, length)
+        new_body = []
+        mono_block_open = false
+        body.each_line do |line|
+          if line.start_with?('```')
+            mono_block_open = !mono_block_open
+            # Don't include code block toggle lines
+            next
+          end
+          new_body += reflow_text_line(line, mono_block_open, length)
+        end
+        new_body.join("\n")
+      end
+    end
+  end
+end

data/lib/uri/finger.rb

@@ -14,13 +14,15 @@ module URI # :nodoc:
     DEFAULT_PORT = 79
 
     # An Array of the available components for URI::Finger.
-    COMPONENT = [:scheme, :userinfo, :host, :port, :path].freeze
+    COMPONENT = %i[scheme userinfo host port path].freeze
 
     def name
       # Utilitary method to extract a name to query, either from the userinfo
       # part or from the path.
       return @user if @user
+
       return '' unless @path
+
       # Remove leading /
       @path[1..] || ''
     end

data/lib/uri/gemini.rb

@@ -7,15 +7,14 @@ module URI # :nodoc:
   # The syntax of Gemini URIs is defined in the Gemini specification,
   # section 1.2.
   #
-  # @see https://gemini.circumlunar.space/docs/specification.html
+  # @see https://geminiprotocol.net/docs/protocol-specification.html
   #
   class Gemini < HTTP
     # A Default port of 1965 for URI::Gemini.
     DEFAULT_PORT = 1965
 
     # An Array of the available components for URI::Gemini.
-    COMPONENT = [:scheme, :host, :port,
-                 :path, :query, :fragment].freeze
+    COMPONENT = %i[scheme host port path query fragment].freeze
   end
 
   if respond_to? :register_scheme

data/lib/uri/gopher.rb

@@ -14,22 +14,24 @@ module URI # :nodoc:
     DEFAULT_PORT = 70
 
     # An Array of the available components for URI::Gopher.
-    COMPONENT = [:scheme, :host, :port, :path].freeze
+    COMPONENT = %i[scheme host port path].freeze
 
     def selector
       return @selector if defined? @selector
+
       @selector = extract_gopher_path_elements[1]
     end
 
     def item_type
       return @item_type if defined? @item_type
+
       @item_type = extract_gopher_path_elements[0]
     end
 
     private
 
     def extract_gopher_path_elements
-      m = /\A\/([0-9+dfghisA-LT])(\/.*)?\Z/.match(@path)
+      m = %r{\A/([0-9+dfghisA-LT])(/.*)?\Z}.match(@path)
       m.captures
     end
   end

data/lib/uri/nex.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'uri'
+
+module URI # :nodoc:
+  #
+  # The syntax of Nex URIs is defined in the Nex specification,
+  # section 1.2.
+  #
+  # @see nex://nightfall.city/nex/info/specification.txt
+  #
+  class Nex < HTTP
+    # A Default port of 1900 for URI::Nex.
+    DEFAULT_PORT = 1900
+
+    # An Array of the available components for URI::Nex.
+    COMPONENT = %i[scheme host port path].freeze
+  end
+
+  if respond_to? :register_scheme
+    # Introduced somewhere in ruby 3.0.x
+    register_scheme 'NEX', Nex
+  else
+    @@schemes['NEX'] = Nex
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-net-text
 version: !ruby/object:Gem::Version
-  version: 0.0.8
+  version: 0.1.0
 platform: ruby
 authors:
 - Étienne Deparis
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-04-18 00:00:00.000000000 Z
+date: 2024-07-13 00:00:00.000000000 Z
 dependencies: []
 description:
 email: etienne@depar.is
@@ -20,16 +20,20 @@ files:
 - README.md
 - lib/net/finger.rb
 - lib/net/gemini.rb
-- lib/net/gemini/gmi_parser.rb
-- lib/net/gemini/reflow_text.rb
+- lib/net/gemini/client.rb
+- lib/net/gemini/client/ssl.rb
+- lib/net/gemini/error.rb
 - lib/net/gemini/request.rb
 - lib/net/gemini/response.rb
-- lib/net/gemini/ssl.rb
-- lib/net/generic.rb
+- lib/net/gemini/response/parser.rb
 - lib/net/gopher.rb
+- lib/net/nex.rb
+- lib/net/text/generic.rb
+- lib/net/text/reflow.rb
 - lib/uri/finger.rb
 - lib/uri/gemini.rb
 - lib/uri/gopher.rb
+- lib/uri/nex.rb
 homepage: https://git.umaneti.net/ruby-net-text/
 licenses:
 - MIT
@@ -38,7 +42,13 @@ metadata:
   source_code_uri: https://git.umaneti.net/ruby-net-text/
   documentation_uri: https://www.rubydoc.info/gems/ruby-net-text
   funding_uri: https://liberapay.com/milouse
-post_install_message:
+post_install_message: |+
+  The version 0.0.9 introduces some breaking changes in Gemini support.
+  If you were using its internal API instead of just using the documented
+  methods, please refer to the README to know more about the changes.
+
+  https://git.umaneti.net/ruby-net-text/about/
+
 rdoc_options: []
 require_paths:
 - lib
@@ -53,8 +63,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.10
+rubygems_version: 3.5.15
 signing_key:
 specification_version: 4
-summary: Gemini, Gopher, and Finger support for Net::* and URI::*
+summary: Finger, Gemini, Gopher and Nex support for Net::* and URI::*
 test_files: []
+...

data/lib/net/gemini/gmi_parser.rb

@@ -1,57 +0,0 @@
-# frozen_string_literal: true
-
-module Gemini
-  # Contains specific method to parse text/gemini documents.
-  module GmiParser
-    private
-
-    def parse_meta
-      header = { status: @status, meta: @meta, mimetype: nil }
-      return header unless body_permitted?
-      mime = { lang: nil, charset: 'utf-8', format: nil }
-      raw_meta = meta.split(';').map(&:strip)
-      header[:mimetype] = raw_meta.shift
-      return header unless raw_meta.any?
-      raw_meta.map { |m| m.split('=') }.each do |opt|
-        key = opt[0].downcase.to_sym
-        next unless mime.has_key? key
-        mime[key] = opt[1].downcase
-      end
-      header.merge(mime)
-    end
-
-    def parse_preformatted_block(line, buf)
-      cur_block = { meta: line[3..].chomp, content: '' }
-      while (line = buf.gets)
-        if line.start_with?('```')
-          @preformatted_blocks << cur_block
-          break
-        end
-        cur_block[:content] += line
-      end
-    end
-
-    def parse_link(line)
-      m = line.strip.match(/\A=>\s*([^\s]+)(?:\s*(.+))?\z/)
-      return if m.nil?
-      begin
-        uri = URI(m[1])
-      rescue URI::InvalidURIError
-        return
-      end
-      uri = @uri.merge(uri) if @uri && uri.is_a?(URI::Generic)
-      @links << { uri: uri, label: m[2]&.chomp }
-    end
-
-    def parse_body
-      buf = StringIO.new(@body)
-      while (line = buf.gets)
-        if line.start_with?('```')
-          parse_preformatted_block(line, buf)
-        elsif line.start_with?('=>')
-          parse_link(line)
-        end
-      end
-    end
-  end
-end

data/lib/net/gemini/reflow_text.rb

@@ -1,62 +0,0 @@
-# frozen_string_literal: true
-
-module Gemini
-  # Contains specific method to correctly display Gemini texts
-  module ReflowText
-    private
-
-    def reflow_line_cut_index(line)
-      possible_cut = [
-        line.rindex(' ') || 0,
-        line.rindex('­') || 0,
-        line.rindex('-') || 0
-      ].sort
-      possible_cut.reverse!
-      possible_cut[0]
-    end
-
-    def reflow_line_prefix(line)
-      m = line.match(/\A([*#>]+ )/)
-      return '' unless m
-      # Each quote line should begin with the quote mark
-      return m[1] if m[1].start_with?('>')
-      ' ' * m[1].length
-    end
-
-    def reflow_text_line(line, mono_block_open, length)
-      line.strip!
-      if mono_block_open || line.start_with?('=>') || line.length < length
-        return [line]
-      end
-      output = []
-      prefix = reflow_line_prefix(line)
-      while line.length > length
-        cut_line = line[0...length]
-        cut_index = reflow_line_cut_index(cut_line)
-        break if cut_index.zero? # Better do nothing for now
-        output << line[0...cut_index]
-        line = prefix + line[cut_index + 1..]
-      end
-      output << line
-    end
-
-    def reformat_body(length)
-      unless length.is_a? Integer
-        raise ArgumentError, "Length must be Integer, #{length} given"
-      end
-      return @body if length.zero?
-      new_body = []
-      mono_block_open = false
-      buf = StringIO.new(@body)
-      while (line = buf.gets)
-        if line.start_with?('```')
-          mono_block_open = !mono_block_open
-          # Don't include code block toggle lines
-          next
-        end
-        new_body += reflow_text_line(line, mono_block_open, length)
-      end
-      new_body.join("\n")
-    end
-  end
-end

data/lib/net/gemini/ssl.rb

@@ -1,53 +0,0 @@
-# frozen_string_literal: true
-
-module Gemini
-  # Contains specific method to handle SSL connection
-  module SSL
-    private
-
-    def ssl_check_existing(new_cert, cert_file)
-      raw = File.read cert_file
-      saved_one = OpenSSL::X509::Certificate.new raw
-      return true if saved_one == new_cert
-      # TODO: offer some kind of recuperation
-      warn "#{cert_file} does not match the current host cert!"
-      false
-    end
-
-    def ssl_verify_cb(cert)
-      return false unless OpenSSL::SSL.verify_certificate_identity(cert, @host)
-      cert_file = File.expand_path("#{@certs_path}/#{@host}.pem")
-      return ssl_check_existing(cert, cert_file) if File.exist?(cert_file)
-      FileUtils.mkdir_p(File.expand_path(@certs_path))
-      File.open(cert_file, 'wb') { |f| f.print cert.to_pem }
-      true
-    end
-
-    def ssl_context
-      ssl_context = OpenSSL::SSL::SSLContext.new
-      ssl_context.set_params(verify_mode: OpenSSL::SSL::VERIFY_PEER)
-      ssl_context.min_version = OpenSSL::SSL::TLS1_2_VERSION
-      ssl_context.verify_hostname = true
-      ssl_context.ca_file = '/etc/ssl/certs/ca-certificates.crt'
-      ssl_context.verify_callback = lambda do |preverify_ok, store_context|
-        return true if preverify_ok
-        ssl_verify_cb store_context.current_cert
-      end
-      ssl_context
-    end
-
-    def init_sockets
-      socket = TCPSocket.new(@host, @port)
-      @ssl_socket = OpenSSL::SSL::SSLSocket.new(socket, ssl_context)
-      # Close underlying TCP socket with SSL socket
-      @ssl_socket.sync_close = true
-      @ssl_socket.hostname = @host # SNI
-      @ssl_socket.connect
-    end
-
-    # Closes the SSL and TCP connections.
-    def finish
-      @ssl_socket.close
-    end
-  end
-end

data/lib/net/generic.rb

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-require 'socket'
-
-# Generic interface to be used by specific network protocol implementation.
-module TextGeneric
-  private
-
-  def build_uri(string_or_uri, uri_class)
-    string_or_uri = URI(string_or_uri) if string_or_uri.is_a?(String)
-    return string_or_uri if string_or_uri.is_a?(uri_class)
-    raise ArgumentError, "uri is not a String, nor an #{uri_class.name}"
-  end
-
-  def request(uri, query)
-    sock = TCPSocket.new(uri.host, uri.port)
-    sock.puts query
-    sock.read
-  ensure
-    # Stop remaining connection, even if they should be already cut
-    # by the server
-    sock&.close
-  end
-end