pl_fustigit 0.5.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: b4505f60333c16eddbc339be71658e38554c9835652f13e9c120ac1e09618388
+  data.tar.gz: 4afdd2c689b1019d67dbd9d45f0a902922c485d1b01ffb3a6d73fb1d58a6a94b
+SHA512:
+  metadata.gz: 65d7c2a9980495c1961cc203955a535292d0376c974e1d60b8a7241f09f5d2e6b397fd1f2729868c3da7090a2d273c5c744b83432484abdbbe61c5c1f90a3952
+  data.tar.gz: d0bd11b5f845a28f6f1ce5f63c5a821081b8c1b6994eb42a2255e3c5c6158604954e616c0785ca5e6afe572ad9d7e3ee5a6e88e3c3a0c3151ba165b15ec3e0ce

data/CHANGELOG.md

@@ -0,0 +1,8 @@
+## Changelog
+All notable changes to this project will be documented in this file.
+This project attempts to adhere to [Semantic Versioning](http://semver.org/).
+This changelog attempts to adhere to [Keep a CHANGELOG](http://keepachangelog.com/).
+
+## [0.5.0] - 21 February 2024
+### Changed
+- Forked from mckern/fustigit; hopefully as a temporary measure.

data/LICENSE

@@ -0,0 +1,13 @@
+Copyright 2014-2022 Ryan McKern
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

data/README.md

@@ -0,0 +1,87 @@
+## Fustigit: gorram Git addresses
+
+<dl>
+    <dt>Fustigate &#8212; (verb) fus&middot;ti&middot;gate </dd>
+    <dd>To beat with a club; cudgel.</dd>
+    <dd>To criticize harshly.</dd>
+</dl>
+
+[![Test & Lint](https://github.com/mckern/fustigit/actions/workflows/tests.yaml/badge.svg)](https://github.com/mckern/fustigit/actions/workflows/tests.yaml)
+[![Gem Version](https://badge.fury.io/rb/fustigit.svg)](https://badge.fury.io/rb/fustigit)
+
+### TL;DR
+
+Fustigit will let you "parse" SCP-like address triplets using Ruby's baked-in [URI library](https://ruby-doc.org/stdlib-2.5.7/libdoc/uri/rdoc/index.html) (... and just a *moderate* amount of monkey-patching) and turn them into probably-valid URI objects.
+
+### What's a Triplet?
+
+<a href="https://www.debuggex.com/r/NtHqyDI9LUz-UMia"><img src="readme/railroad-diagram.jpg"></a>
+
+A triplet is a format for specifying a remote resource, much like a URI. It looks like this:
+
+    # The username is optional but the hostname and pathname are not
+    <username>@<hostname>:<pathname>
+
+Triplets predate the [original ratification of the URI RFC](https://tools.ietf.org/html/rfc2396), and are *tricksy* to parse if you're playing by URI rules since they don't define a protocol and they use a colon to separate the hostname from the pathname. `scp` and `git` are the two most common tools that still use triplets.
+
+### Why would I need to parse triplets?
+
+The answer is usually "[Git](https://git-scm.com)" (but sometimes it's `scp`). Git supports a conveniently inconvenient number of formats for expressing where a remote repository is located and/or what protocol should be used to connect to it. Some of them are perfectly valid URIs. Some of them are not. It's the ones that are not that may be a problem.
+
+```yaml
+---
+# These won't parse and they're both SUPER common
+- example.com:path/to/repo.git
+- git@example.com:user/project.git
+
+# But these will parse, which is great since they're also SUPER common
+- https://example.com/user/project.git
+- http://example.com/user/project.git
+```
+
+Enter Fustigit.
+
+### How (do I use this)?
+
+<s>Carelessly</s> Without a care in the world!
+
+```ruby
+>> URI.parse "git@github.com:mckern/fustigit.git"
+URI::InvalidURIError: bad URI(is not URI?): git@github.com:mckern/fustigit.git [/some/path/for/ruby/lib/ruby/2.1.0/uri/common.rb:176:in `split']
+>> require 'fustigit'
+=> true
+>> uri = URI.parse "git@github.com:mckern/fustigit.git"
+=> #<URI::SSH:0x007f8459131f98 URL:git@github.com:mckern/fustigit.git>
+>> uri.host
+=> "github.com"
+>> uri.user
+=> "git"
+>> uri.path
+=> "mckern/fustigit.git"
+>> uri.to_s
+=> "git@github.com:mckern/fustigit.git"
+>>
+```
+
+### How (does it work)?
+
+Careful use of `Module#prepend` and `Module#extend` in `URI` and `URI::Parser`, judicious use of regular expressions, and by defining a few new `URI` subclasses: `URI::Git`, `URI::SSH`, `URI::SCP`, and `URI::RSYNC`. Some of these classes then have the `Triplet` module mixed in, which helps smooth over the conversion between a valid RFC-compliant URI and an address triplet.
+
+### What if I'm using `Addressable::URI` instead of `::URI`?
+
+Take a look at Martin Emde's [Gitable](https://github.com/martinemde/gitable), which extends `Addressable::URI` with additional support for Git addresses.
+
+### Support & contribution?
+
+In the spirit of Jordan Sissel (a hero to admins and operations people everywhere), if fustigit is not helping you parse weird Git addresses, then there is a bug in fustigit. Please open an issue or submit a pull request if something doesn't work.
+
+### License
+
+Fustigate is licensed under the Apache License, Version 2.0.
+
+> "When in doubt, use brute force."
+>    &#8213; <cite>Ken Thompson</cite>
+
+### Maintainer
+
+Ryan McKern &lt;ryan@mckern.sh&gt;

data/lib/pl_fustigit.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require "uri/triplets"
+require "uri/git"
+require "uri/scp"
+require "uri/ssh"
+require "uri/rsync"

data/lib/uri/git.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require "uri/generic"
+
+module URI
+  class Git < Generic
+    include Triplets
+
+    DEFAULT_PORT = 9418
+    USE_REGISTRY = false
+
+    COMPONENT = %i[
+      scheme
+      userinfo
+      host port path
+    ].freeze
+  end
+  if respond_to? :register_scheme
+    register_scheme "GIT", Git
+  else
+    @@schemes["GIT"] = Git
+  end
+end

data/lib/uri/rsync.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require "uri/generic"
+
+module URI
+  class RSYNC < Generic
+    DEFAULT_PORT = 873
+  end
+  if respond_to? :register_scheme
+    register_scheme "RSYNC", RSYNC
+  else
+    @@schemes["RSYNC"] = RSYNC
+  end
+end

data/lib/uri/scp.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require "uri/generic"
+
+module URI
+  class SCP < Generic
+    include Triplets
+
+    DEFAULT_PORT = 22
+
+    COMPONENT = %i[
+      scheme
+      userinfo
+      host port path
+    ].freeze
+  end
+  if respond_to? :register_scheme
+    register_scheme "SCP", SCP
+  else
+    @@schemes["SCP"] = SCP
+  end
+end

data/lib/uri/ssh.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require "uri/generic"
+
+module URI
+  class SSH < Generic
+    include Triplets
+
+    DEFAULT_PORT = 22
+
+    COMPONENT = %i[
+      scheme
+      userinfo
+      host port path
+    ].freeze
+  end
+  if respond_to? :register_scheme
+    register_scheme "SSH", SSH
+  else
+    @@schemes["SSH"] = SSH
+  end
+end

data/lib/uri/triplets.rb

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+require "uri"
+
+# Triplets is a mix-in for subclasses of URI::Generic, which
+# allows URI to use SCP-style Triplet URLs in a somewhat more
+# meaningful way.
+module Triplets
+  attr_accessor :scheme, :user, :host, :path
+
+  # @return [String] a string representation of the URI components
+  # as an SCP-style Triplet
+  def triplet
+    str = []
+    str << "#{user}@" if user && !user.empty?
+    str << "#{host}:#{path}".squeeze("/")
+    str.join
+  end
+  private :triplet
+
+  # @return [String] a string representation of the URI components
+  # as a valid RFC compliant URI
+  # rubocop:disable Metrics/AbcSize
+  def rfc_uri
+    str = []
+    str << "#{scheme}://" if scheme
+    str << "#{user}@" if user
+    if port && port != self.class::DEFAULT_PORT
+      host_info = [host, port].join(":")
+      str << [host_info, path].join("/").squeeze("/")
+    else
+      str << [host, path].join("/").squeeze("/")
+    end
+    str.join
+  end
+  private :rfc_uri
+  # rubocop:enable Metrics/AbcSize
+
+  def to_s
+    return triplet if triplet?
+
+    rfc_uri
+  end
+
+  # Use the same regular expressions that the parser uses to determine
+  # if this is a valid triplet.
+  def triplet?
+    # False if self matches a normal URI scheme
+    rfc_uri !~ URI.parser.const_get(:TI_SCHEME) &&
+      # False unless self matches a Triplet scheme
+      !!(triplet =~ URI.parser.const_get(:TI_TRIPLET))
+  end
+end
+
+# A SCP Triplet is *not* a canonical URI. It doesn't follow any RFCs that
+# I've been able to find, and it's difficult to reason about if you
+# try to force it into a URI::Generic as-is. TripletInterruptus provides
+# helper methods that preserve the upstream behavior of URI::Generic
+# but extend it just enough that it doesn't choke on SCP Triplets if
+# they're passed.
+module TripletInterruptus
+  # Determine if a string can be teased apart into URI-like components
+  TI_TRIPLET = %r{\A(?:(?<userinfo>.+)@+)?(?<host>[\w.-]+):(?<path>.*)\z}
+
+  # Determine if a string is prefixed with a URI scheme like http:// or ssh://
+  TI_SCHEME = %r{\A(?:(?<scheme>[a-z]+)://)}
+
+  def parse(uri)
+    return build_triplet(uri) if triplet?(uri)
+
+    super(uri)
+  end
+
+  def split(uri)
+    return super(uri) unless triplet?(uri)
+
+    parts = parse_triplet(uri)
+    [nil, parts[:userinfo], parts[:host], nil,
+     nil, parts[:path], nil, nil, nil]
+  end
+
+  def triplet?(address)
+    address.match(TI_TRIPLET) && !address.match(TI_SCHEME)
+  end
+
+  def build_triplet(address)
+    values = parse_triplet(address)
+    return nil unless values
+
+    URI.scheme_list[URI.default_triplet_type].build(values)
+  end
+  private :build_triplet
+
+  def parse_triplet(address)
+    parts = address.match(TI_TRIPLET)
+    return nil unless parts
+
+    parts.names.map(&:to_sym).zip(parts.captures).to_h
+  end
+  private :parse_triplet
+end
+
+module TripletHandling
+  TRIPLET_CLASSES = %w[Git SCP SSH].freeze
+
+  def self.included(base)
+    base.extend(TripletHandling)
+  end
+
+  def default_triplet_type
+    @default_triplet_type ||= "SSH"
+  end
+
+  def default_triplet_type=(value)
+    raise ArgumentError, "'#{value}' is not one of: #{TRIPLET_CLASSES.join(', ')}" unless TRIPLET_CLASSES.include?(value)
+
+    @default_triplet_type = value
+  end
+
+  def parser
+    return URI::RFC3986_Parser if
+      Gem::Version.new(RUBY_VERSION) >= Gem::Version.new("2.2.0")
+
+    URI::Parser
+  end
+end
+
+# Reopen URI and include TripletHandling (which will then
+# extend URI to add triplet-specific class methods).
+module URI
+  include TripletHandling
+end
+
+module URI
+  # Reopen URI::Parser and prepend TripletInterruptus. This
+  # allows us to hook into URI::Parser.parse and attempt to
+  # parse a triplet before URI::Parser can reject it. Otherwise
+  # fall through to the original URI::Parser.parse method.
+  #
+  if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new("2.2.0")
+    # rubocop:disable Naming/ClassAndModuleCamelCase
+    class RFC3986_Parser
+      prepend TripletInterruptus
+    end
+    # rubocop:enable Naming/ClassAndModuleCamelCase
+  else
+    class Parser
+      prepend TripletInterruptus
+    end
+  end
+end

metadata

@@ -0,0 +1,54 @@
+--- !ruby/object:Gem::Specification
+name: pl_fustigit
+version: !ruby/object:Gem::Version
+  version: 0.5.2
+platform: ruby
+authors:
+- Ryan McKern
+- Puppet Release Engineering
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2024-02-21 00:00:00.000000000 Z
+dependencies: []
+description: |
+  Forked from mckern/fustigit, it will "Parse" SCP-like address triplets with the standard
+  Ruby URI Library.
+email: release@puppet.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE
+- README.md
+- lib/pl_fustigit.rb
+- lib/uri/git.rb
+- lib/uri/rsync.rb
+- lib/uri/scp.rb
+- lib/uri/ssh.rb
+- lib/uri/triplets.rb
+homepage: http://github.com/puppetlabs/pl_fustigit
+licenses:
+- Apache-2.0
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3
+signing_key: 
+specification_version: 4
+summary: Use URI to "parse" SCP-like triplets
+test_files: []