ruby-net-text 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 95abe1fa0498d496b10d7517d9dc00fcd958091e93c75cb3f86d3274667bf245
+  data.tar.gz: 92855326685c71635f9a3f0c45178112925ecbd2e30027c187d473b3ddc61e07
+SHA512:
+  metadata.gz: 7342a84385b98b84f7dc74ad546c78d58f943412da84fb247c3eff4b0affcce5ca9fa446ea527de5f32b983ee86589a57a217ad2debab57c9ede7cda0855d7d8
+  data.tar.gz: 17e634cc19ff48ef976db87c85155dc618a37c3e24d8dc2edd443eae647602aa6d7d9880dbb6968f289d4ad2c6a47b990ae7622abacb9d61788b023a960894bc

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 Étienne Deparis
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/lib/net/gemini.rb

@@ -0,0 +1,197 @@
+# frozen_string_literal: true
+
+# This file is derived from "net/http.rb".
+
+require 'socket'
+require 'openssl'
+require 'fileutils'
+
+require 'uri/gemini'
+require_relative 'gemini/response'
+
+module Net
+  class GeminiError < StandardError; end
+
+  # == A Gemini client API for Ruby.
+  #
+  # Net::Gemini provides a rich library which can be used to build
+  # Gemini user-agents.
+  # @see https://gemini.circumlunar.space/docs/specification.html
+  #
+  # Net::Gemini is designed to work closely with URI.
+  #
+  # == Simple Examples
+  #
+  # All examples assume you have loaded Net::Gemini with:
+  #
+  #   require 'net/gemini'
+  #
+  # This will also require 'uri' so you don't need to require it
+  # separately.
+  #
+  # The Net::Gemini methods in the following section do not persist
+  # connections.
+  #
+  # === GET by URI
+  #
+  #   uri = URI('gemini://example.com/index.html?count=10')
+  #   Net::Gemini.get(uri) # => String
+  #
+  # === GET with Dynamic Parameters
+  #
+  #   uri = URI('gemini://example.com/index.html')
+  #   params = { :limit => 10, :page => 3 }
+  #   uri.query = URI.encode_www_form(params)
+  #
+  #   res = Net::Gemini.get_response(uri)
+  #   puts res.body if res.body_permitted?
+  #
+  # === Response Data
+  #
+  #   res = Net::Gemini.get_response(URI('gemini://exemple.com/home'))
+  #
+  #   # Status
+  #   puts res.status # => '20'
+  #   puts res.meta   # => 'text/gemini; charset=UTF-8; lang=en'
+  #
+  #   # Headers
+  #   puts res.header.inspect
+  #   # => { status: '20', meta: 'text/gemini; charset=UTF-8',
+  #           mimetype: 'text/gemini', lang: 'en',
+  #           charset: 'utf-8', format: nil }
+  #
+  # The lang, charset and format headers will only be provided in case
+  # of `text/*` mimetype, and only if body for 2* status codes.
+  #
+  #   # Body
+  #   puts res.body if res.body_permitted?
+  #   puts res.body(flowed: 85)
+  #
+  # === Following Redirection
+  #
+  # The {#fetch} method, contrary to the {#request} one will try to
+  # automatically resolves redirection, leading you to the final
+  # destination.
+  #
+  #   u = URI('gemini://exemple.com/redirect')
+  #   res = Net::Gemini.start(u.host, u.port) do |g|
+  #     g.request(u)
+  #   end
+  #   puts "#{res.status} - #{res.meta}" # => '30 final/dest'
+  #   puts res.uri.to_s                  # => 'gemini://exemple.com/redirect'
+  #
+  #   u = URI('gemini://exemple.com/redirect')
+  #   res = Net::Gemini.start(u.host, u.port) do |g|
+  #     g.fetch(u)
+  #   end
+  #   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
+      @ssl_socket.puts "#{uri}\r\n"
+      r = GeminiResponse.read_new(@ssl_socket)
+      r.uri = uri
+      r.reading_body(@ssl_socket)
+    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'
+      old_url = uri.to_s
+      begin
+        new_uri = URI(r.meta)
+        uri.merge!(new_uri)
+      rescue ArgumentError, URI::InvalidURIError
+        return r
+      end
+      raise GeminiError, "Redirect loop on #{uri}" if uri.to_s == old_url
+      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 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)
+      domain = cert.subject.to_s.sub(/^\/CN=/, '')
+      return false if domain != @host
+      cert_file = File.expand_path("#{@certs_path}/#{domain}.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/gemini/response.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+require 'English'
+require 'stringio'
+
+require_relative 'gmi_parser'
+require_relative 'reflow_text'
+
+module Net
+  class GeminiBadResponse < StandardError; end
+
+  #
+  # The syntax of Gemini Responses are defined in the Gemini
+  #   specification[1], section 3.
+  #
+  # [1] https://gemini.circumlunar.space/docs/specification.html
+  #
+  class GeminiResponse
+    # The Gemini response <STATUS> string.
+    #
+    # For example, '20'.
+    attr_reader :status
+
+    # The Gemini response <META> message sent by the server as a string.
+    #
+    # 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
+
+    def body_permitted?
+      @status && @status[0] == '2'
+    end
+
+    def reading_body(sock)
+      return self unless body_permitted?
+      raw_body = []
+      while (line = sock.gets)
+        raw_body << line
+      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
+
+    class << self
+      def read_new(sock)
+        code, msg = read_status_line(sock)
+        new(code, msg)
+      end
+
+      private
+
+      def read_status_line(sock)
+        # Read up to 1027 bytes:
+        # - 3 bytes for code and space separator
+        # - 1024 bytes max for the message
+        str = sock.gets($INPUT_RECORD_SEPARATOR, 1027)
+        m = /\A([1-6]\d) (.*)\r\n\z/.match(str)
+        raise GeminiBadResponse, "wrong status line: #{str.dump}" if m.nil?
+        m.captures
+      end
+    end
+
+    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
+
+    include ::Gemini::GmiParser
+    include ::Gemini::ReflowText
+  end
+end

data/lib/uri/finger.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'uri'
+
+module URI # :nodoc:
+  #
+  # The syntax of Finger URIs is defined in the Finger specification,
+  # section 2.3.
+  #
+  # @see https://tools.ietf.org/html/rfc1288#section-2.3
+  #
+  class Finger < HTTP
+    # A Default port of 79 for URI::Finger.
+    DEFAULT_PORT = 79
+
+    # An Array of the available components for URI::Finger.
+    COMPONENT = [:scheme, :userinfo, :host, :port].freeze
+  end
+
+  @@schemes['FINGER'] = Finger
+end

data/lib/uri/gemini.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'uri'
+
+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
+  #
+  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
+  end
+
+  @@schemes['GEMINI'] = Gemini
+end

data/lib/uri/gopher.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'uri'
+
+module URI # :nodoc:
+  #
+  # The syntax of Gopher URIs is defined in the Gopher URI Scheme
+  # specification.
+  #
+  # @see https://www.rfc-editor.org/rfc/rfc4266.html
+  #
+  class Gopher < HTTP
+    # A Default port of 70 for URI::Gopher.
+    DEFAULT_PORT = 70
+
+    # An Array of the available components for URI::Gopher.
+    COMPONENT = [:scheme, :host, :port, :path].freeze
+  end
+
+  @@schemes['GOPHER'] = Gopher
+end

metadata

@@ -0,0 +1,48 @@
+--- !ruby/object:Gem::Specification
+name: ruby-net-text
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Étienne Deparis
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2020-11-15 00:00:00.000000000 Z
+dependencies: []
+description:
+email: etienne@depar.is
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- lib/net/gemini.rb
+- lib/net/gemini/response.rb
+- lib/uri/finger.rb
+- lib/uri/gemini.rb
+- lib/uri/gopher.rb
+homepage: https://git.umaneti.net/ruby-net-text/
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.7'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.4
+signing_key:
+specification_version: 4
+summary: Gemini, Gopher, and Finger support for Net::* and URI::*
+test_files: []