lapis-minecraft-versioning 0.5.0

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

@@ -0,0 +1,69 @@
+require_relative 'basic'
+
+module Lapis
+  module Minecraft
+    module Versioning
+
+      # Additional information about a Minecraft version.
+      class Detailed < Basic
+
+        # Overview of assets included in this version.
+        # @return [AssetIndex]
+        attr_reader :asset_index
+
+        # List of downloads available for this version.
+        # @return [Array<Resource>]
+        attr_reader :downloads
+
+        # List of libraries needed to run this version.
+        # @return [Array<Library>]
+        attr_reader :libraries
+
+        # Information about how to start the client in a launcher.
+        # @return [LauncherProperties]
+        attr_reader :launcher_properties
+
+        # Retrieves the client jar information for this version.
+        # @return [Resource, nil] Download information for the client, or +nil+ if there is no client for this version.
+        attr_reader :client_download
+
+        # Retrieves the server jar information for this version.
+        # @return [Resource, nil] Download information for the server, or +nil+ if there is no server for this version.
+        attr_reader :server_download
+
+        # Creates version information.
+        # @param basic_info [Basic] Minimal information to extend from.
+        # @param asset_index [AssetIndex] Overview of assets needed for the version.
+        # @param downloads [Array<Resource>] List of downloads available for this version.
+        # @param libraries [Array<Library>] List of libraries needed to run this version.
+        # @param launcher_properties [LauncherProperties] Information about how to start the client in a launcher.
+        def initialize(basic_info, asset_index, downloads, libraries, launcher_properties)
+          super(basic_info.id, basic_info.type, basic_info.time, basic_info.url)
+          @asset_index         = asset_index
+          @downloads           = downloads.dup.freeze
+          @libraries           = libraries.dup.freeze
+          @launcher_properties = launcher_properties
+
+          @client_download = downloads.find { |download| download.classifier == 'client' }
+          @server_download = downloads.find { |download| download.classifier == 'server' }
+        end
+
+        # Compares one version to another.
+        # @param other [Detailed] Version to compare against.
+        # @return [true] The versions are the same.
+        # @return [false] The versions are different.
+        def ==(other)
+          super(other) &&
+              other.asset_index == @asset_index &&
+              other.downloads == @downloads &&
+              other.libraries == @libraries &&
+              other.launcher_properties == @launcher_properties &&
+              other.client_download == @client_download &&
+              other.server_download == @server_download
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+module Lapis
+  module Minecraft
+    module Versioning
+
+      # Information about how the client should be started.
+      class LauncherProperties
+
+        # Main Java class that is the entry point for the client.
+        # @return [String]
+        attr_reader :main_class
+
+        # List of arguments to pass to the client jar.
+        # @return [Array<String>]
+        # @note Some arguments may be parametrized with +${var_name}+.
+        attr_reader :arguments
+
+        # Minimum launcher version required to run the client.
+        # @return [Fixnum]
+        # @note This can be ignored if a custom launcher is used.
+        attr_reader :minimum_version
+
+        # Creates properties for launching the client.
+        # @param main_class [String] Main Java class that is the entry point for the client.
+        # @param arguments [Array<String>] List of arguments to pass to the client jar.
+        #   These can be parametrized by using +${var_name}+.
+        # @param minimum_version [Fixnum] Minimum launcher version required to run the client.
+        #   This can be ignored if a custom launcher is used.
+        def initialize(main_class, arguments, minimum_version)
+          @main_class      = main_class.dup.freeze
+          @arguments       = arguments.map(&:freeze).freeze
+          @minimum_version = minimum_version
+        end
+
+        # Compares one set of properties to another.
+        # @param other [LauncherProperties] Properties to compare against.
+        # @return [true] The properties are the same.
+        # @return [false] The properties are different.
+        def ==(other)
+          other.main_class == @main_class &&
+              other.arguments == @arguments &&
+              other.minimum_version == @minimum_version
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+module Lapis
+  module Minecraft
+    module Versioning
+
+      # Dependency needed to run Minecraft.
+      class Library
+
+        # Name of the dependency.
+        # @return [String]
+        attr_reader :name
+
+        # Set of resources included in the library.
+        # @return [ResourceSet]
+        attr_reader :resources
+
+        # Filter for which files should be installed.
+        # @return [Array<Rule>]
+        attr_reader :rules
+
+        # Paths to ignore when extracting resources.
+        # @return [Array<String>]
+        attr_reader :exclude_paths
+
+        # Creates information about a dependency.
+        # @param name [String] Name of the dependency.
+        # @param resources [ResourceSet] Set of resources included in the library.
+        # @param rules [Array<Rule>] Filter for which files should be installed.
+        # @param exclude_paths [Array<String>] Paths to ignore when extracting resources.
+        def initialize(name, resources, rules = [], exclude_paths = [])
+          @name          = name.dup.freeze
+          @resources     = resources
+          @rules         = rules.dup.freeze
+          @exclude_paths = exclude_paths.map(&:freeze).freeze
+        end
+
+        # Compares one library to another.
+        # @param other [Library] Library to compare against.
+        # @return [true] The libraries are the same.
+        # @return [false] The libraries are different.
+        def ==(other)
+          other.name == @name &&
+              other.resources == @resources &&
+              other.rules == @rules &&
+              other.exclude_paths == @exclude_paths
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+module Lapis
+  module Minecraft
+    module Versioning
+
+      # Contains basic information about all known versions of Minecraft.
+      class Manifest
+        include Enumerable
+
+        # Retrieves information about the latest release.
+        # @return [Basic]
+        attr_reader :latest_release
+
+        # Retrieves information about the latest snapshot.
+        # @return [Basic]
+        attr_reader :latest_snapshot
+
+        # Creates a new manifest with version instances.
+        # @param versions [Array<Basic>] List of all versions.
+        # @param latest_release_id [String] ID of the version for the latest release.
+        # @param latest_snapshot_id [String] ID of the version for the latest snapshot.
+        def initialize(versions, latest_release_id, latest_snapshot_id)
+          @versions        = versions.dup.freeze
+          @latest_release  = versions.find { |version| version.id == latest_release_id }
+          @latest_snapshot = versions.find { |version| version.id == latest_snapshot_id }
+        end
+
+        def each
+          return enum_for(:each) unless block_given?
+
+          @versions.each do |version|
+            yield version
+          end
+        end
+
+        # Compares one manifest to another.
+        # @param other [Manifest] Manifest to compare against.
+        # @return [true] The manifests are the same.
+        # @return [false] The manifests are different.
+        def ==(other)
+          other.entries == @versions &&
+              other.latest_release == @latest_release &&
+              other.latest_snapshot == @latest_snapshot
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+module Lapis
+  module Minecraft
+    module Versioning
+
+      # Logic for handling marshaled forms of version information.
+      module Marshalling
+      end
+
+    end
+  end
+end
+
+require_relative 'marshalling/asset_index_parser'
+require_relative 'marshalling/version_parser'
+require_relative 'marshalling/manifest_parser'

data/lib/lapis/minecraft/versioning/marshalling/asset_index_parser.rb

@@ -0,0 +1,41 @@
+require 'json'
+
+module Lapis
+  module Minecraft
+    module Versioning
+      module Marshalling
+
+        # Reads an asset index document and generates an {AssetIndex} instance.
+        # @see AssetIndex
+        # @todo JSON and structural errors are not detected and handled elegantly.
+        class AssetIndexParser
+
+          # Extract asset information from an asset index document.
+          # @param document [String] Contents of the asset index document.
+          # @return [Array<Asset>]
+          def parse(document)
+            structure = JSON.parse(document)
+            structure['objects'].map do |path, attributes|
+              unmarshal_asset(path, attributes)
+            end
+          end
+
+          private
+
+          # Create an instance from the marshaled form of an {Asset}.
+          # @param path [String] Path to the stored asset.
+          # @param attributes [Hash{String => String, Fixnum}] Other attributes of the asset.
+          #   This should include +hash+ or +sha1+, which is the SHA-1 hash,
+          #   and +size+, which is the size in bytes.
+          # @return [Asset]
+          def unmarshal_asset(path, attributes)
+            size = attributes['size']
+            sha1 = attributes['sha1'] || attributes['hash']
+            Asset.new(size, sha1, path)
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/lapis/minecraft/versioning/marshalling/manifest_parser.rb

@@ -0,0 +1,66 @@
+require_relative '../manifest'
+require_relative '../basic'
+
+module Lapis
+  module Minecraft
+    module Versioning
+      module Marshalling
+
+        # Reads a manifest document and retrieves basic version information from it.
+        # @see Manifest
+        # @todo JSON and structural errors are not detected and handled elegantly.
+        class ManifestParser
+
+          # Retrieves information about versions from a manifest document.
+          # @param document [String] Contents of the version manifest document.
+          # @return [Manifest]
+          def parse(document)
+            structure = JSON.parse(document)
+            versions  = unmarshal_versions(structure['versions'])
+            latest_release_id, latest_snapshot_id = unmarshal_latest(structure['latest'])
+            Manifest.new(versions, latest_release_id, latest_snapshot_id)
+          end
+
+          private
+
+          # Extract versions from a marshaled list format.
+          # @param versions [Array<Hash>] List of version information.
+          # @return [Array<Version>]
+          def unmarshal_versions(versions)
+            versions.map do |attributes|
+              unmarshal_version(attributes)
+            end
+          end
+
+          # Extract basic version information from a marshaled format.
+          # @param attributes [Hash<String => String>] Information about the version.
+          # @return [Basic]
+          def unmarshal_version(attributes)
+            id       = attributes['id']
+            time     = Time.parse(attributes['releaseTime'])
+            url      = attributes['url']
+            type_str = attributes['type']
+            type = case type_str
+                     when /alpha/
+                       :alpha
+                     when /beta/
+                       :beta
+                     else
+                       type_str.to_sym
+                   end
+            Basic.new(id, type, time, url)
+          end
+
+          # Extract IDs of the latest release and snapshot from a marshaled format.
+          # @param attributes [Hash<String => String>] Information about the latest versions.
+          # @return [Array<String>] Two-item array containing the ID of the latest release and snapshot (in that order).
+          def unmarshal_latest(attributes)
+            return attributes['release'], attributes['snapshot']
+          end
+
+        end
+
+      end
+    end
+  end
+end

data/lib/lapis/minecraft/versioning/marshalling/version_parser.rb

@@ -0,0 +1,204 @@
+require 'json'
+require_relative '../detailed'
+require_relative '../basic'
+require_relative '../asset_index'
+require_relative '../resource'
+require_relative '../resource_set'
+require_relative '../rule'
+require_relative '../os_rule'
+require_relative '../library'
+require_relative '../launcher_properties'
+
+module Lapis
+  module Minecraft
+    module Versioning
+      module Marshalling
+
+        # Reads a version document and generates a {Detailed} instance.
+        # @see Detailed
+        # @todo JSON and structural errors are not detected and handled elegantly.
+        class VersionParser
+
+          # Retrieves detailed information from a version document.
+          # @param document [String] Contents of the version document.
+          # @param url [String] Location of the version document.
+          # @return [Detailed]
+          def parse(document, url)
+            structure = JSON.parse(document)
+            basic               = unmarshal_basic_info(structure, url)
+            asset_index         = unmarshal_asset_index(structure['assetIndex'])
+            downloads           = unmarshal_downloads(structure['downloads'])
+            libraries           = unmarshal_libraries(structure['libraries'])
+            launcher_properties = unmarshal_launcher_properties(structure)
+            Detailed.new(basic, asset_index, downloads, libraries, launcher_properties)
+          end
+
+          private
+
+          # Extract basic version info from the marshaled form of a {Detailed} version.
+          # @param attributes [Hash] Version information.
+          # @option attributes [String] :id Unique name of the version.
+          # @option attributes [String] :type Type of version - alpha, beta, snapshot, or release.
+          # @option attributes [String] :releaseTime Date and time the version was released.
+          # @param url [String] Location of the version document.
+          def unmarshal_basic_info(attributes, url)
+            id   = attributes['id']
+            time = Time.parse(attributes['releaseTime'])
+            type = case attributes['type']
+                     when 'old_alpha'
+                       :alpha
+                     when 'old_beta'
+                       :beta
+                     else
+                       attributes['type'].to_sym
+                   end
+            Basic.new(id, type, time, url)
+          end
+
+          # Create an instance from the marshaled form of an {AssetIndex}.
+          # @param attributes [Hash{String => String, Fixnum}] Information about the asset index.
+          # @option attributes [String] :id Name of the asset index.
+          # @option attributes [String] :sha1 SHA-1 hash of the asset index document in hexadecimal.
+          # @option attributes [Fixnum] :size Size of the asset index document in bytes.
+          # @option attributes [String] :url Location of the asset index document.
+          # @option attributes [Fixnum] :totalSize Size, in bytes, of all assets in the index.
+          # @return [AssetIndex]
+          def unmarshal_asset_index(attributes)
+            id         = attributes['id']
+            sha1       = attributes['sha1']
+            size       = attributes['size']
+            url        = attributes['url']
+            total_size = attributes['totalSize']
+            AssetIndex.new(id, sha1, size, url, total_size)
+          end
+
+          # Extract a set of downloads from a marshaled list.
+          # @param downloads [Hash<String => Hash>] List of marshaled download information.
+          # @return [Array<Resource>]
+          def unmarshal_downloads(downloads)
+            downloads.map { |label, attributes| unmarshal_download(label, attributes) }
+          end
+
+          # Extract information about a resource.
+          # @param label [String] Classifier given in the document.
+          # @param attributes [Hash<String => String, Fixnum>] Information about the resource.
+          # @option attributes [String] :sha1 SHA-1 hash of the download in hexadecimal.
+          # @option attributes [Fixnum] :size Size of the download in bytes.
+          # @option attributes [String] :url Location of the download.
+          # @option attributes [String] :path Location to place the download in.
+          # @return [Resource]
+          def unmarshal_download(label, attributes)
+            sha1 = attributes['sha1']
+            size = attributes['size']
+            url  = attributes['url']
+            path = attributes['path']
+            Resource.new(url, size, sha1, path, label)
+          end
+
+          # Extract a set of libraries from a marshaled list.
+          # @param libraries [Array<Hash>] List of marshaled library information.
+          # @return [Array<Library>]
+          def unmarshal_libraries(libraries)
+            libraries.map { |attributes| unmarshal_library(attributes) }
+          end
+
+          # Extract a library from a marshaled format.
+          # @param attributes [Hash] Information about the library.
+          # @option attributes [String] :name Formal name of the library.
+          # @option attributes [Hash<String => Hash>] :downloads Set of downloads included in the library.
+          # @option attributes [Hash<String => String>] :natives Classifiers for native downloads.
+          # @option attributes [Array<Hash>] :rules Library application rules.
+          # @option attributes [Hash<String => Array>] :extract Extraction rules.
+          # @return [Library]
+          def unmarshal_library(attributes)
+            name      = attributes['name']
+            downloads = unmarshal_library_downloads(attributes['downloads'])
+            natives   = unmarshal_library_natives(attributes['natives'])
+            resources = ResourceSet.new(downloads, natives[0], natives[1], natives[2])
+            rules     = unmarshal_library_rules(attributes['rules'])
+            paths     = unmarshal_library_paths(attributes['extract'])
+            Library.new(name, resources, rules, paths)
+          end
+
+          # Extract a set of downloads included in a library.
+          # @param downloads [Array<Hash>] List of marshaled download information.
+          # @return [Array<Resource>]
+          def unmarshal_library_downloads(downloads)
+            resources = []
+            if downloads.key?('artifact')
+              resources << unmarshal_download('artifact', downloads['artifact'])
+            end
+            if downloads.key?('classifiers')
+              downloads['classifiers'].each do |classifier, attributes|
+                resources << unmarshal_download(classifier, attributes)
+              end
+            end
+            resources
+          end
+
+          # Extract the classifiers for natives.
+          # @param natives [Hash<String => String>] Classifier information.
+          # @return [Array<String>] Array of three items: Windows classifier, Linux classifier, and OSX classifier.
+          def unmarshal_library_natives(natives)
+            if natives
+              [natives['windows'], natives['linux'], natives['osx']]
+            else
+              [nil, nil, nil]
+            end
+          end
+
+          # Extract library exclude paths from a marshaled format.
+          # @param attributes [Hash<String => Array>] Path information.
+          # @return [Array<String>]
+          def unmarshal_library_paths(attributes)
+            if attributes && attributes.key?('exclude')
+              attributes['exclude']
+            else
+              []
+            end
+          end
+
+          # Extract library application rules from a marshaled format.
+          # @param rules [Array<Hash>] List of marshaled rule information.
+          # @return [Array<Rule>]
+          def unmarshal_library_rules(rules)
+            if rules
+              rules.map { |attributes| unmarshal_library_rule(attributes) }
+            else
+              []
+            end
+          end
+
+          # Extract library rule from a marshaled format.
+          # @param attributes [Hash] Rule requirements.
+          # @return [Rule]
+          def unmarshal_library_rule(attributes)
+            action = attributes['action'] == 'allow'
+            if attributes.key?('os')
+              os_type    = attributes['os']['name'].to_sym
+              os_version = attributes['os']['version']
+              OSRule.new(action, os_type, os_version)
+            else
+              Rule.new(action)
+            end
+          end
+
+          # Extract launcher properties from a marshaled format.
+          # @param attributes [Hash] Version information (launcher properties are embedded).
+          # @option attributes [String] :mainClass Name of the main class in the client.
+          # @option attributes [String] :arguments Command-line arguments to pass into the client.
+          # @option attributes [Fixnum] :minimumVersion Minimum version of the Minecraft launcher needed to run the client.
+          # @return [LauncherProperties]
+          def unmarshal_launcher_properties(attributes)
+            main_class      = attributes['mainClass']
+            arguments       = attributes['minecraftArguments'].split(/\s+/)
+            minimum_version = attributes['minimumLauncherVersion']
+            LauncherProperties.new(main_class, arguments, minimum_version)
+          end
+
+        end
+
+      end
+    end
+  end
+end