fustigit 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 551f4ad9ed874b976c1de00a5289a1352d946d64
+  data.tar.gz: 1954e7f60f0c10a423f8a2cc0f16d0a09ba4d085
+SHA512:
+  metadata.gz: fe5bbee3df3198f8d9d93f7cc88a27c1609c2ee952e25a65884016f07b5e44b15a3d98cbe0c88e773b9f8806dc6788172708eb59be85d8bacee65b353ed88d61
+  data.tar.gz: 50f90dbc0e42dca704a759d2ab68feb3a2ab326a380b4733ff848099b45a2e1fbd4e54850c587eb72befbabe34a633b37b908ff41cfdb7ac3d08675767896861

data/CHANGELOG.md

@@ -0,0 +1,15 @@
+## 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.1.1] - 09 May 2016
+### Added
+- Fix Ruby 2.2.0 and 2.3.0 support
+- Add JRuby to Travis checks
+- Make Rubocop print cop names by default
+
+## [0.1.0] - 09 May 2016
+### Added
+- Initial release
+- README covers usage, licensing, and rationale

data/LICENSE

@@ -0,0 +1,13 @@
+Copyright 2014-2016 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,86 @@
+## 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>
+
+[![Build Status](https://travis-ci.org/mckern/fustigit.svg?branch=master)](https://travis-ci.org/mckern/fustigit)
+
+### TL;DR
+
+Fustigit will let you "parse" SCP-like address triplets using Ruby's baked-in [URI library](http://ruby-doc.org/stdlib-2.3.1/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/UF-0ESZoWXFewi8q"><img src="https://www.debuggex.com/i/UF-0ESZoWXFewi8q.png"></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@orangefort.com&gt;

data/Rakefile

@@ -0,0 +1,30 @@
+require "bundler/setup"
+require "bundler/gem_tasks"
+require "rake/testtask"
+require "rubocop/rake_task"
+
+desc "Test fustigit"
+namespace :test do
+  Rake::TestTask.new(:spec) do |test|
+    test.libs << "spec"
+    test.pattern = "spec/**/*_spec.rb"
+    test.verbose = false
+    test.warning = false
+  end
+
+  desc "Test fustigit and calculate test coverage"
+  task :coverage do
+    ENV["COVERAGE"] = "true"
+    Rake::Task["test:spec"].invoke
+  end
+end
+
+desc "Run RuboCop"
+RuboCop::RakeTask.new(:rubocop) do |task|
+  task.patterns = ["lib/**/*.rb"]
+end
+
+desc "Run all spec tests and linters"
+task check: %w(test:spec rubocop)
+
+task default: :check

data/lib/fustigit.rb

@@ -0,0 +1,5 @@
+require "uri/triplets"
+require "uri/git"
+require "uri/scp"
+require "uri/ssh"
+require "uri/rsync"

data/lib/fustigit/version.rb

@@ -0,0 +1,5 @@
+module Fustigit
+  module Version
+    VERSION = "0.1.1".freeze
+  end
+end

data/lib/uri/git.rb

@@ -0,0 +1,17 @@
+require "uri/generic"
+
+module URI
+  class Git < Generic
+    include Triplets
+
+    DEFAULT_PORT = 9418
+    USE_REGISTRY = false
+
+    COMPONENT = [
+      :scheme,
+      :userinfo,
+      :host, :port, :path
+    ].freeze
+  end
+  @@schemes["GIT"] = Git
+end

data/lib/uri/rsync.rb

@@ -0,0 +1,8 @@
+require "uri/generic"
+
+module URI
+  class RSYNC < Generic
+    DEFAULT_PORT = 873
+  end
+  @@schemes["RSYNC"] = RSYNC
+end

data/lib/uri/scp.rb

@@ -0,0 +1,16 @@
+require "uri/generic"
+
+module URI
+  class SCP < Generic
+    include Triplets
+
+    DEFAULT_PORT = 22
+
+    COMPONENT = [
+      :scheme,
+      :userinfo,
+      :host, :port, :path
+    ].freeze
+  end
+  @@schemes["SCP"] = SCP
+end

data/lib/uri/ssh.rb

@@ -0,0 +1,16 @@
+require "uri/generic"
+
+module URI
+  class SSH < Generic
+    include Triplets
+
+    DEFAULT_PORT = 22
+
+    COMPONENT = [
+      :scheme,
+      :userinfo,
+      :host, :port, :path
+    ].freeze
+  end
+  @@schemes["SSH"] = SSH
+end

data/lib/uri/triplets.rb

@@ -0,0 +1,123 @@
+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("/")
+  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
+  end
+  private :rfc_uri
+
+  # if self.path is a relative path, assume that this was parsed
+  # as a triplet and return a Triplet. Otherwise, assume that
+  # this is a valid URI and print an RFC compliant URI. This
+  # may not be the most robust method of determining if a
+  # triplet should be used, but everything starts someplace.
+  def to_s
+    return triplet if relative?
+    rfc_uri
+  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
+  TRIPLET = %r{\A(?:(?<userinfo>.+)[@]+)?(?<host>[\w.]+):(?<path>.*)\z}
+
+  # Determine if a string is prefixed with a URI scheme like http:// or ssh://
+  SCHEME = %r{\A(?:(?<scheme>[a-z]+)://)}
+
+  def parse(uri)
+    return build_triplet(uri) if triplet?(uri)
+    super(uri)
+  end
+
+  def triplet?(address)
+    address.match(TRIPLET) && !address.match(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(TRIPLET)
+    return nil unless parts
+    Hash[parts.names.map(&:to_sym).zip(parts.captures)]
+  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)
+    unless TRIPLET_CLASSES.include?(value)
+      raise ArgumentError, "'#{value}' is not one of: #{TRIPLET_CLASSES.join(', ')}"
+    end
+    @default_triplet_type = value
+  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 Style/ClassAndModuleCamelCase
+    class RFC3986_Parser
+      prepend TripletInterruptus
+    end
+  else
+    class Parser
+      prepend TripletInterruptus
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,22 @@
+require "bundler/setup"
+require "minitest/spec"
+require "minitest/autorun"
+require "minitest/reporters"
+require "simplecov"
+require "json"
+
+Minitest::Reporters.use! Minitest::Reporters::DefaultReporter.new
+
+if ENV["COVERAGE"]
+  SimpleCov.start do
+    # exclude common Bundler locations
+    %w(.bundle vendor).each { |dir| add_filter dir }
+    # exclude test code
+    add_filter "spec"
+  end
+end
+
+def fixture(path)
+  path = File.join(File.dirname(__FILE__), "fixtures", path)
+  File.read(path)
+end

data/spec/uri/fustigit_spec.rb

@@ -0,0 +1,31 @@
+require "spec_helper"
+require "fustigit"
+
+describe URI do
+  @git_repos = JSON.load(fixture("formats.json"))
+  @git_repos["URIs"].each do |protocol, repos|
+    repos.each do |repo|
+      describe %(#parse takes given URI "#{repo}") do
+        it "returns URI::#{protocol}" do
+          URI.parse(repo).is_a?(URI.const_get(protocol)).must_equal true
+        end
+      end
+    end
+  end
+
+  @git_repos["paths"].each do |repo|
+    describe %(#parse takes path "#{repo}") do
+      it "returns URI::Generic" do
+        URI.parse(repo).is_a?(URI::Generic).must_equal true
+      end
+    end
+  end
+
+  @git_repos["triplets"].each do |repo|
+    describe %(#parse takes triplet "#{repo}") do
+      it "returns URI::#{URI.default_triplet_type}" do
+        URI.parse(repo).is_a?(URI.const_get(URI.default_triplet_type)).must_equal true
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,60 @@
+--- !ruby/object:Gem::Specification
+name: fustigit
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- Ryan McKern
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-05-09 00:00:00.000000000 Z
+dependencies: []
+description: '"Parse" SCP-like address triplets with the Standard Ruby URI Library.'
+email: ryan@orangefort.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE
+- README.md
+- Rakefile
+- lib/fustigit.rb
+- lib/fustigit/version.rb
+- lib/uri/git.rb
+- lib/uri/rsync.rb
+- lib/uri/scp.rb
+- lib/uri/ssh.rb
+- lib/uri/triplets.rb
+- spec/spec_helper.rb
+- spec/uri/fustigit_spec.rb
+homepage: http://github.com/mckern/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: 2.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.4
+signing_key: 
+specification_version: 3
+summary: Use URI to "parse" SCP-like triplets
+test_files:
+- Rakefile
+- spec/spec_helper.rb
+- spec/uri/fustigit_spec.rb
+has_rdoc: