lapis-minecraft-versioning 0.5.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b5bf6625d5970b1ef1e843dbc6739c336c63e8c9
-  data.tar.gz: 7c063ac81ca87f18f731780a626f8c6812118c94
+  metadata.gz: 875492c8026a073c5e304f467850f1f1716f872a
+  data.tar.gz: 9881c4542bbf404d6448766601e07368c8909abc
 SHA512:
-  metadata.gz: b3cdce6908cc39176ae0a07f855e0ab25839e03a27d4d8b2c1c13412cf15416f8170446f10417a029324bbf34d8a2a30d4bd132a15207fc5f5a388f83e553167
-  data.tar.gz: 9a8cdf5b7d0b9be57859457fa6414c2bd68fdddc5123ff63a953590ff1e95114ca2d8ff78635d44a1f532f653ceadf07c1066885a79a27249357307b73b8d995
+  metadata.gz: 5499dd5d3cd4a84534dcca77bb0e19bf3769e4b25c388d9980dc7805f9a63139d1b088f4a2ce3982e8f14cae3b099c8b1a56eedc3b7a8a787f6cbe86156fafa5
+  data.tar.gz: 12227c1b6777b082fdbc82912f92891a3f7953f36966d5039ed6edc62ec9cbc68788be629d113b8c075fd4e1486c0d0e47313ae9982f83e9d240b46a638f20e7

data/README.md

@@ -5,6 +5,7 @@ Minecraft Version Info
 [![Code Climate](https://codeclimate.com/github/lapis-mc/minecraft-versioning/badges/gpa.svg)](https://codeclimate.com/github/lapis-mc/minecraft-versioning)
 [![Test Coverage](https://codeclimate.com/github/lapis-mc/minecraft-versioning/badges/coverage.svg)](https://codeclimate.com/github/lapis-mc/minecraft-versioning/coverage)
 [![Issue Count](https://codeclimate.com/github/lapis-mc/minecraft-versioning/badges/issue_count.svg)](https://codeclimate.com/github/lapis-mc/minecraft-versioning)
+[![Documentation](https://inch-ci.org/github/lapis-mc/minecraft-versioning.svg?branch=master)](http://www.rubydoc.info/github/lapis-mc/minecraft-versioning/master)
 
 Retrieves and processes information about versions of Minecraft.
 Small library for getting version information from Mojang about Minecraft.
@@ -36,13 +37,15 @@ Or install it yourself as:
 Usage
 -----
 
+### Script usage
+
 Include the gem by adding this to your scripts:
 
 ```ruby
 require 'lapis/minecraft/versioning'
 ```
 
-### Accessing Minecraft version data
+#### Accessing Minecraft version data
 
 Retrieve the official Minecraft version list:
 
@@ -64,6 +67,73 @@ Get the client URL for the latest release:
 list.latest_release.client_download.url
 ```
 
+### Command-line usage
+
+This gem comes with a script named `minecraft-versions`.
+It can display most information about versions - some information is too complex to display.
+The following commands are available:
+
+```sh
+minecraft-versions list [TYPE]
+minecraft-versions info <ID>
+minecraft-versions client <ID>
+minecraft-versions server <ID>
+minecraft-versions assets <ID>
+minecraft-versions libraries <ID>
+minecraft-versions latest-id [TYPE]
+minecraft-versions latest [TYPE]
+```
+
+#### `list [TYPE]`
+
+Lists the identifiers of all known Minecraft versions.
+These are the IDs used for other commands.
+`TYPE` can be provided to filter which versions are listed.
+`TYPE` can be one of: `alpha`, `beta`, `snapshot`, `release`, or `all`.
+The default is `all`.
+
+#### `info <ID>`
+
+Displays top-level information about the specified Minecraft version.
+`ID` is the identifier of the version to display information for.
+
+#### `client <ID>`
+
+Outputs just the client download URL for a specific Minecraft version.
+`ID` is the identifier of the version to get the client for.
+
+#### `server <ID>`
+
+Outputs just the server download URL for a specific Minecraft version.
+`ID` is the identifier of the version to get the server for.
+
+#### `assets <ID>`
+
+Displays a list of all the assets used by the client.
+`ID` is the identifier of the version to get an asset list for.
+`ID` is *not* the asset index name.
+
+#### `libraries <ID>`
+
+Displays a list of all the libraries needed for a specific version of Minecraft.
+`ID` is the identifier of the version to get the libraries for.
+
+#### `latest-id [TYPE]`
+
+Outputs just the ID of the latest Minecraft version.
+`TYPE` can be specified to filter which versions are considered.
+`TYPE` can be one of: `alpha`, `beta`, `snapshot`, `release`, or `any`.
+When set to `any`, the latest version, regardless of type is displayed.
+The default is `release`.
+
+#### `latest [TYPE]`
+
+Displays top-level information for the latest Minecraft version.
+`TYPE` can be specified to filter which versions are considered.
+`TYPE` can be one of: `alpha`, `beta`, `snapshot`, `release`, or `any`.
+When set to `any`, the latest version, regardless of type is displayed.
+The default is `release`.
+
 Development
 -----------
 

data/bin/minecraft-versions

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'lapis/minecraft/versioning'
+require 'lapis/minecraft/versioning/cli'
+
+Lapis::Minecraft::Versioning::CLI.start(ARGV)

data/lapis-minecraft-versioning.gemspec

@@ -22,6 +22,7 @@ Includes a command-line utility as well.}
   spec.require_paths = ['lib']
 
   spec.add_dependency 'httpclient', '~> 2.1'
+  spec.add_dependency 'thor'
 
   spec.add_development_dependency 'bundler'
   spec.add_development_dependency 'rake', '~> 10.0'

data/lib/lapis/minecraft/versioning/cli.rb

@@ -0,0 +1,171 @@
+require 'thor'
+require_relative '../versioning'
+
+module Lapis
+  module Minecraft
+    module Versioning
+
+      # Command-line interface for retrieving version information.
+      # @note This class is not included by default with `lapis/minecraft/versioning`.
+      class CLI < Thor
+
+        class_option :url, :aliases => :u, :type => :string, :banner => 'MANIFEST_URL', :desc => 'Custom manifest URL to get version data from', :default => Lapis::Minecraft::Versioning::VersionList::OFFICIAL_MANIFEST_URL
+
+        desc 'list [TYPE]', 'List all available Minecraft versions'
+        long_desc <<-LONG_DESC
+          Lists the identifiers of all known Minecraft versions.
+          TYPE can be provided to filter which versions are listed.
+          TYPE can be one of: alpha, beta, snapshot, release, or all.
+          The default is all.
+        LONG_DESC
+        def list(type = 'all')
+          type_sym = type.downcase.to_sym
+          versions = case type_sym
+                       when :alpha, :beta, :snapshot, :release
+                         filter(type_sym)
+                       else # all
+                         version_list
+                     end
+          versions.each do |version|
+            puts version.id
+          end
+        end
+
+        desc 'info <ID>', 'Display information about a version'
+        long_desc <<-LONG_DESC
+          Displays top-level information about the specified Minecraft version.
+          ID is the identifier of the version to display information for.
+        LONG_DESC
+        def info(id)
+          version = version_list[id]
+          display_info(version)
+        end
+
+        desc 'client <ID>', 'Get the URL for the client download'
+        long_desc <<-LONG_DESC
+          Outputs just the client download URL for a specific Minecraft version.
+          ID is the identifier of the version to get the client for.
+        LONG_DESC
+        def client(id)
+          version = version_list[id]
+          puts version.client_download.url
+        end
+
+        desc 'server <ID>', 'Get the URL for the server download'
+        long_desc <<-LONG_DESC
+          Outputs just the server download URL for a specific Minecraft version.
+          ID is the identifier of the version to get the server for.
+        LONG_DESC
+        def server(id)
+          version = version_list[id]
+          puts version.server_download.url
+        end
+
+        desc 'assets <ID>', 'List assets used by a version'
+        long_desc <<-LONG_DESC
+          Displays a list of all the assets used by the client.
+          ID is the identifier of the version to get an asset list for.
+          ID is *not* the asset index name.
+        LONG_DESC
+        def assets(id)
+          version = version_list[id]
+          max_size_length = version.assets.map { |asset| asset.size.to_s.length }.max
+          version.assets.each do |asset|
+            printf("%s %#{max_size_length}d %s\n", asset.sha1, asset.size, asset.path)
+          end
+        end
+
+        desc 'libraries <ID>', 'List libraries used by a version'
+        long_desc <<-LONG_DESC
+          Displays a list of all the libraries needed for a specific version of Minecraft.
+          ID is the identifier of the version to get the libraries for.
+        LONG_DESC
+        def libraries(id)
+          version = version_list[id]
+          version.libraries.each do |library|
+            puts library.name
+          end
+        end
+
+        desc 'latest-id [TYPE]', 'Get the ID of the latest version'
+        long_desc <<-LONG_DESC
+          Outputs just the ID of the latest Minecraft version.
+          TYPE can be specified to filter which versions are considered.
+          TYPE can be one of: alpha, beta, snapshot, release, or any.
+          When set to 'any', the latest version, regardless of type is displayed.
+          The default is 'release'.
+        LONG_DESC
+        def latest_id(type = 'release')
+          puts latest_version(type).id
+        end
+
+        desc 'latest [TYPE]', 'Display information about the latest version'
+        long_desc <<-LONG_DESC
+          Displays top-level information for the latest Minecraft version.
+          TYPE can be specified to filter which versions are considered.
+          TYPE can be one of: alpha, beta, snapshot, release, or any.
+          When set to 'any', the latest version, regardless of type is displayed.
+          The default is 'release'.
+        LONG_DESC
+        def latest(type = 'release')
+          version = latest_version(type)
+          display_info(version)
+        end
+
+        private
+
+        # Retrieve and cache the version list.
+        # @return [VersionList]
+        def version_list
+          @version_list ||= Lapis::Minecraft::Versioning::VersionList.new(options[:url])
+        end
+
+        # Retrieve a list of versions based on type.
+        # @param type [Symbol] One of: +:alpha+, +:beta+, +:snapshot+, or +:release+.
+        # @return [Array<Version>] Filtered version list.
+        def filter(type)
+          version_list.select do |version|
+            version.type == type
+          end
+        end
+
+        # Retrieve the latest version of a given type.
+        # @param type [String] One of: `alpha`, `beta`, `snapshot`, `release`, or `any`.
+        # @return [Version] Latest version of the given type.
+        def latest_version(type)
+          case type.to_s.downcase
+            when 'release'
+              version_list.latest_release
+            when 'snapshot'
+              version_list.latest_snapshot
+            when 'beta'
+              filter(:beta).max_by { |v| v.time }
+            when 'alpha'
+              filter(:alpha).max_by { |v| v.time }
+            else # any
+              version_list.max_by { |v| v.time }
+          end
+        end
+
+        # Outputs information about a version.
+        # Libraries, assets, and other complex data is omitted.
+        # @param version [Version] Version to output information for.
+        # @return [void]
+        def display_info(version)
+          puts <<-END_INFO
+Version:      #{version.id}
+Type:         #{version.type.to_s.capitalize}
+Released:     #{version.time.utc}
+Assets:       #{version.asset_index.id}
+Assets Size:  #{version.asset_index.total_size}
+Main Class:   #{version.launcher_properties.main_class}
+Arguments:    #{version.launcher_properties.arguments.join(' ')}
+Min Launcher: #{version.launcher_properties.minimum_version}
+          END_INFO
+        end
+
+      end
+
+    end
+  end
+end

data/lib/lapis/minecraft/versioning/manifest.rb

@@ -24,6 +24,9 @@ module Lapis
           @latest_snapshot = versions.find { |version| version.id == latest_snapshot_id }
         end
 
+        # Iterates over all versions.
+        # @yieldparam version [Basic] Next version in the list.
+        # @return [Enumerator<Basic>]
         def each
           return enum_for(:each) unless block_given?
 
@@ -32,6 +35,14 @@ module Lapis
           end
         end
 
+        # Retrieves version information given a specific ID.
+        # @param id [String] ID of the version to retrieve.
+        # @return [Basic] Version information.
+        # @return [nil] No version with the provided ID exists.
+        def [](id)
+          @versions.find { |version| version.id == id }
+        end
+
         # Compares one manifest to another.
         # @param other [Manifest] Manifest to compare against.
         # @return [true] The manifests are the same.

data/lib/lapis/minecraft/versioning/version.rb

@@ -1,7 +1,7 @@
 module Lapis
   module Minecraft
     module Versioning
-      VERSION = '0.5.0'
+      VERSION = '0.6.0'
     end
   end
 end

data/lib/lapis/minecraft/versioning/version_list.rb

@@ -28,7 +28,7 @@ module Lapis
 
         # Iterates over all versions.
         # @yieldparam version [Version] Next version in the list.
-        # @return [void]
+        # @return [Enumerator<Version>]
         def each
           return enum_for(:each) unless block_given?
 
@@ -37,6 +37,18 @@ module Lapis
           end
         end
 
+        # Retrieves version information given a specific ID.
+        # @param id [String] ID of the version to retrieve.
+        # @return [Version] Version information.
+        # @return [nil] No version with the provided ID exists.
+        def [](id)
+          if (basic = manifest[id])
+            Version.new(basic, @meta_server)
+          else
+            nil
+          end
+        end
+
         # Retrieves the latest released version.
         # @return [Version] Version information.
         def latest_release

data/spec/lapis/minecraft/versioning/cli_spec.rb

@@ -0,0 +1,625 @@
+require_relative '../../../spec_helper'
+require_relative '../../../../lib/lapis/minecraft/versioning/cli'
+
+# Generate a regular expression that matches all items in a list in any order.
+# The regular expression matches one item per line.
+# @param items [Array] List of items to match.
+# @return [Regexp]
+def any_order_regexp(items)
+  Regexp.new(items.map do |item|
+    "(?=.*^#{Regexp.escape(item.to_s)}$)"
+  end.join, Regexp::MULTILINE)
+end
+
+# Generate a regular expression that matches all items in a list in any order.
+# The regular expression matches one item per non-word boundary.
+# @param items [Array] List of items to match.
+# @return [Regexp]
+def any_order_regexp_bounds(items)
+  Regexp.new(items.map do |item|
+    "(?=.*(\\A|\\W)#{Regexp.escape(item.to_s)}(\\Z|\\W))"
+  end.join, Regexp::MULTILINE)
+end
+
+RSpec.describe Lapis::Minecraft::Versioning::CLI do
+  let(:assets) { build_list(:asset, 20) }
+  let(:releases) do
+    (1..3).map do |i|
+      build(:detailed, :release, :time => (14 + i).days.ago, :assets => assets)
+    end
+  end
+  let(:snapshots) do
+    (1..3).map do |i|
+      build(:detailed, :snapshot, :time => (7 + i).days.ago, :assets => assets)
+    end
+  end
+  let(:betas) do
+    (1..3).map do |i|
+      build(:detailed, :beta, :time => (21 + i).days.ago, :assets => assets)
+    end
+  end
+  let(:alphas) do
+    (1..3).map do |i|
+      build(:detailed, :alpha, :time => (28 + i).days.ago, :assets => assets)
+    end
+  end
+  let(:latest_release) { build(:detailed, :release, :time => 2.days.ago, :assets => assets) }
+  let(:latest_snapshot) { build(:detailed, :snapshot, :time => 1.days.ago, :assets => assets) }
+  let(:versions) { releases + snapshots + betas + alphas << latest_release << latest_snapshot }
+  let(:manifest) { build(:manifest, :versions => versions, :latest_release_id => latest_release.id, :latest_snapshot_id => latest_snapshot.id) }
+  let(:manifest_document) { build(:manifest_document, :source => manifest).document }
+  subject(:cli) { Lapis::Minecraft::Versioning::CLI.start(argv) }
+
+  before(:each) do
+    stub_request(:get, Lapis::Minecraft::Versioning::VersionList::OFFICIAL_MANIFEST_URL).to_return(status: 200, body: manifest_document, headers: {})
+    versions.each do |version|
+      version_document = build(:version_document, :source => version).document
+      stub_request(:get, version.url).to_return(status: 200, body: version_document, headers: {})
+      asset_index_document = build(:asset_index_document, :assets => assets).document
+      stub_request(:get, version.asset_index.url).to_return(status: 200, body: asset_index_document, headers: {})
+    end
+  end
+
+  describe '#list' do
+    let(:argv) { %w(list) }
+
+    it 'outputs all versions' do
+      regexp = any_order_regexp(versions.map(&:id))
+      expect { cli }.to output(regexp).to_stdout
+    end
+
+    context 'with release type' do
+      let(:argv) { %w(list release) }
+
+      it 'outputs all release versions' do
+        regexp = any_order_regexp(releases.map(&:id))
+        expect { cli }.to output(regexp).to_stdout
+      end
+
+      it 'does not output non-release versions' do
+        versions = snapshots + betas + alphas
+        regexp   = any_order_regexp(versions.map(&:id))
+        expect { cli }.to_not output(regexp).to_stdout
+      end
+    end
+
+    context 'with snapshot type' do
+      let(:argv) { %w(list snapshot) }
+
+      it 'outputs all snapshot versions' do
+        regexp = any_order_regexp(snapshots.map(&:id))
+        expect { cli }.to output(regexp).to_stdout
+      end
+
+      it 'does not output non-snapshot versions' do
+        versions = releases + betas + alphas
+        regexp = any_order_regexp(versions.map(&:id))
+        expect { cli }.to_not output(regexp).to_stdout
+      end
+    end
+
+    context 'with beta type' do
+      let(:argv) { %w(list beta) }
+
+      it 'outputs all beta versions' do
+        regexp = any_order_regexp(betas.map(&:id))
+        expect { cli }.to output(regexp).to_stdout
+      end
+
+      it 'does not output non-beta versions' do
+        versions = releases + snapshots + alphas
+        regexp = any_order_regexp(versions.map(&:id))
+        expect { cli }.to_not output(regexp).to_stdout
+      end
+    end
+
+    context 'with alpha type' do
+      let(:argv) { %w(list alpha) }
+
+      it 'outputs all alpha versions' do
+        regexp = any_order_regexp(alphas.map(&:id))
+        expect { cli }.to output(regexp).to_stdout
+      end
+
+      it 'does not output non-release versions' do
+        versions = releases + snapshots + betas
+        regexp = any_order_regexp(versions.map(&:id))
+        expect { cli }.to_not output(regexp).to_stdout
+      end
+    end
+
+    context 'with all type' do
+      let(:argv) { %w(list all) }
+
+      it 'outputs all versions' do
+        regexp = any_order_regexp(versions.map(&:id))
+        expect { cli }.to output(regexp).to_stdout
+      end
+    end
+  end
+
+  describe '#info' do
+    let(:version) { releases.first }
+    let(:argv) { ['info', version.id] }
+
+    it 'outputs the version ID' do
+      regexp = Regexp.new(Regexp.escape(version.id))
+      expect { cli }.to output(regexp).to_stdout
+    end
+
+    it 'outputs the type' do
+      expect { cli }.to output(/#{version.type}/i).to_stdout
+    end
+
+    it 'outputs the time' do
+      regexp = Regexp.new(Regexp.escape(version.time.to_s))
+      expect { cli }.to output(regexp).to_stdout
+    end
+
+    context 'asset index' do
+      let(:index) { version.asset_index }
+
+      it 'outputs the index name' do
+        regexp = Regexp.new("assets?\\W+(index\\W+)?" + Regexp.escape(index.id), Regexp::IGNORECASE)
+        expect { cli }.to output(regexp).to_stdout
+      end
+
+      it 'outputs the total size' do
+        expect { cli }.to output(/size\W+#{index.total_size}/i).to_stdout
+      end
+    end
+
+    context 'launcher properties' do
+      let(:launcher) { version.launcher_properties }
+
+      it 'outputs the main class' do
+        regexp = Regexp.new(Regexp.escape(launcher.main_class))
+        expect { cli }.to output(regexp).to_stdout
+      end
+
+      it 'outputs the arguments' do
+        arg_str = launcher.arguments.join(' ')
+        regexp  = Regexp.new(Regexp.escape(arg_str))
+        expect { cli }.to output(regexp).to_stdout
+      end
+
+      it 'outputs the minimum version' do
+        regexp = Regexp.new("launcher\\W+(version\\W+)?" + Regexp.escape(launcher.minimum_version.to_s), Regexp::IGNORECASE)
+        expect { cli }.to output(regexp).to_stdout
+      end
+    end
+  end
+
+  describe '#client' do
+    let(:version) { releases.first }
+    let(:argv) { ['client', version.id] }
+
+    it 'outputs the client URL' do
+      expect { cli }.to output(version.client_download.url + "\n").to_stdout
+    end
+  end
+
+  describe '#server' do
+    let(:version) { releases.first }
+    let(:argv) { ['server', version.id] }
+
+    it 'outputs the server URL' do
+      expect { cli }.to output(version.server_download.url + "\n").to_stdout
+    end
+  end
+
+  describe '#assets' do
+    let(:version) { releases.first }
+    let(:argv) { ['assets', version.id] }
+
+    it 'outputs all asset paths' do
+      regexp = any_order_regexp_bounds(assets.map(&:path))
+      expect { cli }.to output(regexp).to_stdout
+    end
+
+    it 'outputs all asset sizes' do
+      regexp = any_order_regexp_bounds(assets.map(&:size))
+      expect { cli }.to output(regexp).to_stdout
+    end
+
+    it 'outputs all asset hashes' do
+      regexp = any_order_regexp_bounds(assets.map(&:sha1))
+      expect { cli }.to output(regexp).to_stdout
+    end
+  end
+
+  describe '#libraries' do
+    let(:version) { releases.first }
+    let(:argv) { ['libraries', version.id] }
+
+    it 'outputs all library names' do
+      regexp = any_order_regexp(version.libraries.map(&:name))
+      expect { cli }.to output(regexp).to_stdout
+    end
+  end
+
+  describe '#latest_id' do
+    let(:version) { latest_release }
+    let(:argv) { %w(latest-id) }
+
+    it 'outputs the latest release ID' do
+      expect { cli }.to output(version.id + "\n").to_stdout
+    end
+
+    context 'with release type' do
+      let(:argv) { %w(latest-id release) }
+
+      it 'outputs the latest release ID' do
+        expect { cli }.to output(version.id + "\n").to_stdout
+      end
+    end
+
+    context 'with snapshot type' do
+      let(:version) { latest_snapshot }
+      let(:argv) { %w(latest-id snapshot) }
+
+      it 'outputs the latest snapshot ID' do
+        expect { cli }.to output(version.id + "\n").to_stdout
+      end
+    end
+
+    context 'with beta type' do
+      let(:version) { betas.max_by { |v| v.time } }
+      let(:argv) { %w(latest-id beta) }
+
+      it 'outputs the latest beta ID' do
+        expect { cli }.to output(version.id + "\n").to_stdout
+      end
+    end
+
+    context 'with alpha type' do
+      let(:version) { alphas.max_by { |v| v.time } }
+      let(:argv) { %w(latest-id alpha) }
+
+      it 'outputs the latest alpha ID' do
+        expect { cli }.to output(version.id + "\n").to_stdout
+      end
+    end
+
+    context 'with any type' do
+      let(:version) { versions.max_by { |v| v.time } }
+      let(:argv) { %w(latest-id any) }
+
+      it 'outputs the latest version ID' do
+        expect { cli }.to output(version.id + "\n").to_stdout
+      end
+    end
+  end
+
+  describe '#latest' do
+    let(:version) { latest_release }
+    let(:argv) { %w(latest) }
+
+    it 'outputs the version ID' do
+      regexp = Regexp.new(Regexp.escape(version.id))
+      expect { cli }.to output(regexp).to_stdout
+    end
+
+    it 'outputs the type' do
+      expect { cli }.to output(/#{version.type}/i).to_stdout
+    end
+
+    it 'outputs the time' do
+      regexp = Regexp.new(Regexp.escape(version.time.to_s))
+      expect { cli }.to output(regexp).to_stdout
+    end
+
+    context 'asset index' do
+      let(:index) { version.asset_index }
+
+      it 'outputs the index name' do
+        regexp = Regexp.new("assets?\\W+(index\\W+)?" + Regexp.escape(index.id), Regexp::IGNORECASE)
+        expect { cli }.to output(regexp).to_stdout
+      end
+
+      it 'outputs the total size' do
+        expect { cli }.to output(/size\W+#{index.total_size}/i).to_stdout
+      end
+    end
+
+    context 'launcher properties' do
+      let(:launcher) { version.launcher_properties }
+
+      it 'outputs the main class' do
+        regexp = Regexp.new(Regexp.escape(launcher.main_class))
+        expect { cli }.to output(regexp).to_stdout
+      end
+
+      it 'outputs the arguments' do
+        arg_str = launcher.arguments.join(' ')
+        regexp  = Regexp.new(Regexp.escape(arg_str))
+        expect { cli }.to output(regexp).to_stdout
+      end
+
+      it 'outputs the minimum version' do
+        regexp = Regexp.new("launcher\\W+(version\\W+)?" + Regexp.escape(launcher.minimum_version.to_s), Regexp::IGNORECASE)
+        expect { cli }.to output(regexp).to_stdout
+      end
+    end
+
+    context 'with release type' do
+      let(:version) { latest_release }
+      let(:argv) { %w(latest release) }
+
+      it 'outputs the version ID' do
+        regexp = Regexp.new(Regexp.escape(version.id))
+        expect { cli }.to output(regexp).to_stdout
+      end
+
+      it 'outputs the type' do
+        expect { cli }.to output(/#{version.type}/i).to_stdout
+      end
+
+      it 'outputs the time' do
+        regexp = Regexp.new(Regexp.escape(version.time.to_s))
+        expect { cli }.to output(regexp).to_stdout
+      end
+
+      context 'asset index' do
+        let(:index) { version.asset_index }
+
+        it 'outputs the index name' do
+          regexp = Regexp.new("assets?\\W+(index\\W+)?" + Regexp.escape(index.id), Regexp::IGNORECASE)
+          expect { cli }.to output(regexp).to_stdout
+        end
+
+        it 'outputs the total size' do
+          expect { cli }.to output(/size\W+#{index.total_size}/i).to_stdout
+        end
+      end
+
+      context 'launcher properties' do
+        let(:launcher) { version.launcher_properties }
+
+        it 'outputs the main class' do
+          regexp = Regexp.new(Regexp.escape(launcher.main_class))
+          expect { cli }.to output(regexp).to_stdout
+        end
+
+        it 'outputs the arguments' do
+          arg_str = launcher.arguments.join(' ')
+          regexp  = Regexp.new(Regexp.escape(arg_str))
+          expect { cli }.to output(regexp).to_stdout
+        end
+
+        it 'outputs the minimum version' do
+          regexp = Regexp.new("launcher\\W+(version\\W+)?" + Regexp.escape(launcher.minimum_version.to_s), Regexp::IGNORECASE)
+          expect { cli }.to output(regexp).to_stdout
+        end
+      end
+    end
+
+    context 'with snapshot type' do
+      let(:version) { latest_snapshot }
+      let(:argv) { %w(latest snapshot) }
+
+      it 'outputs the version ID' do
+        regexp = Regexp.new(Regexp.escape(version.id))
+        expect { cli }.to output(regexp).to_stdout
+      end
+
+      it 'outputs the type' do
+        expect { cli }.to output(/#{version.type}/i).to_stdout
+      end
+
+      it 'outputs the time' do
+        regexp = Regexp.new(Regexp.escape(version.time.to_s))
+        expect { cli }.to output(regexp).to_stdout
+      end
+
+      context 'asset index' do
+        let(:index) { version.asset_index }
+
+        it 'outputs the index name' do
+          regexp = Regexp.new("assets?\\W+(index\\W+)?" + Regexp.escape(index.id), Regexp::IGNORECASE)
+          expect { cli }.to output(regexp).to_stdout
+        end
+
+        it 'outputs the total size' do
+          expect { cli }.to output(/size\W+#{index.total_size}/i).to_stdout
+        end
+      end
+
+      context 'launcher properties' do
+        let(:launcher) { version.launcher_properties }
+
+        it 'outputs the main class' do
+          regexp = Regexp.new(Regexp.escape(launcher.main_class))
+          expect { cli }.to output(regexp).to_stdout
+        end
+
+        it 'outputs the arguments' do
+          arg_str = launcher.arguments.join(' ')
+          regexp  = Regexp.new(Regexp.escape(arg_str))
+          expect { cli }.to output(regexp).to_stdout
+        end
+
+        it 'outputs the minimum version' do
+          regexp = Regexp.new("launcher\\W+(version\\W+)?" + Regexp.escape(launcher.minimum_version.to_s), Regexp::IGNORECASE)
+          expect { cli }.to output(regexp).to_stdout
+        end
+      end
+    end
+
+    context 'with beta type' do
+      let(:version) { betas.max_by { |v| v.time } }
+      let(:argv) { %w(latest beta) }
+
+      it 'outputs the version ID' do
+        regexp = Regexp.new(Regexp.escape(version.id))
+        expect { cli }.to output(regexp).to_stdout
+      end
+
+      it 'outputs the type' do
+        expect { cli }.to output(/#{version.type}/i).to_stdout
+      end
+
+      it 'outputs the time' do
+        regexp = Regexp.new(Regexp.escape(version.time.to_s))
+        expect { cli }.to output(regexp).to_stdout
+      end
+
+      context 'asset index' do
+        let(:index) { version.asset_index }
+
+        it 'outputs the index name' do
+          regexp = Regexp.new("assets?\\W+(index\\W+)?" + Regexp.escape(index.id), Regexp::IGNORECASE)
+          expect { cli }.to output(regexp).to_stdout
+        end
+
+        it 'outputs the total size' do
+          expect { cli }.to output(/size\W+#{index.total_size}/i).to_stdout
+        end
+      end
+
+      context 'launcher properties' do
+        let(:launcher) { version.launcher_properties }
+
+        it 'outputs the main class' do
+          regexp = Regexp.new(Regexp.escape(launcher.main_class))
+          expect { cli }.to output(regexp).to_stdout
+        end
+
+        it 'outputs the arguments' do
+          arg_str = launcher.arguments.join(' ')
+          regexp  = Regexp.new(Regexp.escape(arg_str))
+          expect { cli }.to output(regexp).to_stdout
+        end
+
+        it 'outputs the minimum version' do
+          regexp = Regexp.new("launcher\\W+(version\\W+)?" + Regexp.escape(launcher.minimum_version.to_s), Regexp::IGNORECASE)
+          expect { cli }.to output(regexp).to_stdout
+        end
+      end
+    end
+
+    context 'with alpha type' do
+      let(:version) { alphas.max_by { |v| v.time } }
+      let(:argv) { %w(latest alpha) }
+
+      it 'outputs the version ID' do
+        regexp = Regexp.new(Regexp.escape(version.id))
+        expect { cli }.to output(regexp).to_stdout
+      end
+
+      it 'outputs the type' do
+        expect { cli }.to output(/#{version.type}/i).to_stdout
+      end
+
+      it 'outputs the time' do
+        regexp = Regexp.new(Regexp.escape(version.time.to_s))
+        expect { cli }.to output(regexp).to_stdout
+      end
+
+      context 'asset index' do
+        let(:index) { version.asset_index }
+
+        it 'outputs the index name' do
+          regexp = Regexp.new("assets?\\W+(index\\W+)?" + Regexp.escape(index.id), Regexp::IGNORECASE)
+          expect { cli }.to output(regexp).to_stdout
+        end
+
+        it 'outputs the total size' do
+          expect { cli }.to output(/size\W+#{index.total_size}/i).to_stdout
+        end
+      end
+
+      context 'launcher properties' do
+        let(:launcher) { version.launcher_properties }
+
+        it 'outputs the main class' do
+          regexp = Regexp.new(Regexp.escape(launcher.main_class))
+          expect { cli }.to output(regexp).to_stdout
+        end
+
+        it 'outputs the arguments' do
+          arg_str = launcher.arguments.join(' ')
+          regexp  = Regexp.new(Regexp.escape(arg_str))
+          expect { cli }.to output(regexp).to_stdout
+        end
+
+        it 'outputs the minimum version' do
+          regexp = Regexp.new("launcher\\W+(version\\W+)?" + Regexp.escape(launcher.minimum_version.to_s), Regexp::IGNORECASE)
+          expect { cli }.to output(regexp).to_stdout
+        end
+      end
+    end
+
+    context 'with any type' do
+      let(:version) { versions.max_by { |v| v.time } }
+      let(:argv) { %w(latest any) }
+
+      it 'outputs the version ID' do
+        regexp = Regexp.new(Regexp.escape(version.id))
+        expect { cli }.to output(regexp).to_stdout
+      end
+
+      it 'outputs the type' do
+        expect { cli }.to output(/#{version.type}/i).to_stdout
+      end
+
+      it 'outputs the time' do
+        regexp = Regexp.new(Regexp.escape(version.time.to_s))
+        expect { cli }.to output(regexp).to_stdout
+      end
+
+      context 'asset index' do
+        let(:index) { version.asset_index }
+
+        it 'outputs the index name' do
+          regexp = Regexp.new("assets?\\W+(index\\W+)?" + Regexp.escape(index.id), Regexp::IGNORECASE)
+          expect { cli }.to output(regexp).to_stdout
+        end
+
+        it 'outputs the total size' do
+          expect { cli }.to output(/size\W+#{index.total_size}/i).to_stdout
+        end
+      end
+
+      context 'launcher properties' do
+        let(:launcher) { version.launcher_properties }
+
+        it 'outputs the main class' do
+          regexp = Regexp.new(Regexp.escape(launcher.main_class))
+          expect { cli }.to output(regexp).to_stdout
+        end
+
+        it 'outputs the arguments' do
+          arg_str = launcher.arguments.join(' ')
+          regexp  = Regexp.new(Regexp.escape(arg_str))
+          expect { cli }.to output(regexp).to_stdout
+        end
+
+        it 'outputs the minimum version' do
+          regexp = Regexp.new("launcher\\W+(version\\W+)?" + Regexp.escape(launcher.minimum_version.to_s), Regexp::IGNORECASE)
+          expect { cli }.to output(regexp).to_stdout
+        end
+      end
+    end
+  end
+
+  describe '--url' do
+    let(:url) { 'http://example.com/foobar/baz/manifest.json' }
+    let(:argv) { ['list', '--url', url] }
+
+    before(:each) do
+      stub_request(:get, url).to_return(status: 200, body: manifest_document, headers: {})
+    end
+
+    it 'uses the specified URL' do
+      expect { cli }.to output.to_stdout # Not important expectation to capture output.
+      expect(cli).to have_requested(:get, url)
+    end
+
+     it 'does not use the default URL' do
+       expect { cli }.to output.to_stdout # Not important expectation to capture output.
+       expect(cli).to_not have_requested(:get, Lapis::Minecraft::Versioning::VersionList::OFFICIAL_MANIFEST_URL)
+     end
+  end
+
+end

data/spec/lapis/minecraft/versioning/manifest_spec.rb

@@ -30,6 +30,27 @@ RSpec.describe Lapis::Minecraft::Versioning::Manifest do
     end
   end
 
+  describe '#[]' do
+    subject { manifest[id] }
+
+    context 'with an existing version' do
+      let(:version) { versions.last }
+      let(:id) { version.id }
+
+      it 'returns the version' do
+        is_expected.to eq version
+      end
+    end
+
+    context 'with a non-existent version' do
+      let(:id) { 'Foobarbaz-non-existent' }
+
+      it 'returns nil' do
+        is_expected.to eq nil
+      end
+    end
+  end
+
   describe '#latest_release' do
     subject { manifest.latest_release }
 

data/spec/lapis/minecraft/versioning/version_list_spec.rb

@@ -47,6 +47,27 @@ RSpec.describe Lapis::Minecraft::Versioning::VersionList do
     end
   end
 
+  describe '#[]' do
+    subject { version_list[id] }
+
+    context 'with an existing version' do
+      let(:version) { betas.first }
+      let(:id) { version.id }
+
+      it 'returns the version' do
+        expect(subject.id).to eq version.id
+      end
+    end
+
+    context 'with a non-existent version' do
+      let(:id) { 'Foobarbaz-non-existent' }
+
+      it 'returns nil' do
+        is_expected.to eq nil
+      end
+    end
+  end
+
   describe '#latest_release' do
     subject { version_list.latest_release }
 

data/spec/spec_helper.rb

@@ -80,7 +80,7 @@ end
 require_relative '../lib/lapis/minecraft/versioning'
 
 # Mock web requests.
-WebMock.disable_net_connect!
+WebMock.disable_net_connect!(:allow => 'codeclimate.com')
 
 # Include helpers.
 require_relative 'time_helper'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lapis-minecraft-versioning
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.6.0
 platform: ruby
 authors:
 - Michael Miller
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-05-10 00:00:00.000000000 Z
+date: 2016-05-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: httpclient
@@ -24,6 +24,20 @@ dependencies:
     - - ~>
       - !ruby/object:Gem::Version
         version: '2.1'
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -155,7 +169,8 @@ description: |-
   Includes a command-line utility as well.
 email:
 - bluepixelmike@gmail.com
-executables: []
+executables:
+- minecraft-versions
 extensions: []
 extra_rdoc_files: []
 files:
@@ -169,6 +184,7 @@ files:
 - README.md
 - Rakefile
 - bin/console
+- bin/minecraft-versions
 - bin/setup
 - lapis-minecraft-versioning.gemspec
 - lib/lapis/minecraft/version.rb
@@ -176,6 +192,7 @@ files:
 - lib/lapis/minecraft/versioning/asset.rb
 - lib/lapis/minecraft/versioning/asset_index.rb
 - lib/lapis/minecraft/versioning/basic.rb
+- lib/lapis/minecraft/versioning/cli.rb
 - lib/lapis/minecraft/versioning/detailed.rb
 - lib/lapis/minecraft/versioning/launcher_properties.rb
 - lib/lapis/minecraft/versioning/library.rb
@@ -211,6 +228,7 @@ files:
 - spec/lapis/minecraft/versioning/asset_index_spec.rb
 - spec/lapis/minecraft/versioning/asset_spec.rb
 - spec/lapis/minecraft/versioning/basic_spec.rb
+- spec/lapis/minecraft/versioning/cli_spec.rb
 - spec/lapis/minecraft/versioning/detailed_spec.rb
 - spec/lapis/minecraft/versioning/launcher_properties_spec.rb
 - spec/lapis/minecraft/versioning/library_spec.rb
@@ -271,6 +289,7 @@ test_files:
 - spec/lapis/minecraft/versioning/asset_index_spec.rb
 - spec/lapis/minecraft/versioning/asset_spec.rb
 - spec/lapis/minecraft/versioning/basic_spec.rb
+- spec/lapis/minecraft/versioning/cli_spec.rb
 - spec/lapis/minecraft/versioning/detailed_spec.rb
 - spec/lapis/minecraft/versioning/launcher_properties_spec.rb
 - spec/lapis/minecraft/versioning/library_spec.rb