mmi 0.2.2 → 0.2.3

data/lib/mmi/modloader/fabric.rb

@@ -1,55 +1,40 @@
 require 'fileutils'
 require 'nokogiri'
+require 'open-uri'
 
-require 'mmi/cached_download'
-require 'mmi/option_attributes'
+require 'mmi/install_utils'
+require 'mmi/constants'
+require 'mmi/content_hash/sha512'
+require 'mmi/property_attributes'
 
 module Mmi
 	module Modloader
 		class Fabric
-			include Mmi::OptionAttributes
+			prepend Mmi::PropertyAttributes
 			
-			opt_accessor :version
-			opt_accessor :install_type
-			opt_accessor :mcversion,    'minecraft_version'
-			opt_accessor(:install_dir                       ) { Mmi.minecraft_dir }
-			opt_accessor(:download_mc,  'download_minecraft') { false             }
+			property :version
+			property :install_type,                                              validate: :validate_install_type
+			property :minecraft_version
+			property :install_dir,        default: Mmi::Constants.minecraft_dir
+			property :download_minecraft, default: false,                        validate: :validate_download_minecraft
 			
-			def initialize(options)
-				@options = options
-				
-				parse!
+			def self.allowed_install_types
+				%w[
+					client
+					server
+				]
 			end
 			
-			def parse!
-				if self.version
-					if self.install_type
-						if allowed_install_types.include?(self.install_type)
-							if self.mcversion
-								if [true, false].include?(self.download_mc)
-									# Pass.
-								else
-									raise Mmi::InvalidAttributeError, %Q(Invalid "modloader.download_minecraft". Expecting true or false, got #{self.download_mc.inspect}.)
-								end
-							else
-								raise Mmi::MissingAttributeError, 'Missing "modloader.minecraft_version".'
-							end
-						else
-							raise Mmi::InvalidAttributeError, %Q(Invalid "modloader.install_type". Expecting "client" or "server", got #{self.install_type.inspect}.)
-						end
-					else
-						raise Mmi::MissingAttributeError, 'Missing "modloader.install_type".'
-					end
-				else
-					raise Mmi::MissingAttributeError, 'Missing "modloader.version".'
+			def self.validate_install_type(value, errors)
+				if !allowed_install_types.include?(value)
+					errors << %Q{modloader "install_type" must be one of #{allowed_install_types.map(&:inspect).join(', ')}}
 				end
 			end
 			
-			def allowed_install_types
-				%w[
-					client
-					server
-				]
+			def self.validate_download_minecraft(value, errors)
+				if ![true, false].include?(value)
+					errors << 'modloader "download_minecraft" must be true or false'
+				end
 			end
 			
 			def base_uri
@@ -65,7 +50,7 @@ module Mmi
 			end
 			
 			def metadata_path
-				File.join(Mmi.cache_dir, 'fabric_maven_metadata.xml')
+				File.join(Mmi::Constants.cache_dir, 'fabric_maven_metadata.xml')
 			end
 			
 			def installer_uri
@@ -77,7 +62,7 @@ module Mmi
 			end
 			
 			def installer_path
-				File.join(Mmi.cache_dir, "fabric-installer-#{self.version}.jar")
+				File.join(Mmi::Constants.cache_dir, "fabric-installer-#{self.version}.jar")
 			end
 			
 			def absolute_install_dir
@@ -85,19 +70,25 @@ module Mmi
 			end
 			
 			def download_installer
-				Mmi.info "Downloading fabric-installer version #{self.version.inspect}."
+				installer_hash = Mmi::ContentHash::Sha512.new(URI.parse(installer_sha512sum_uri).read)
 				
-				begin
-					Mmi::CachedDownload.download_cached(installer_uri, installer_path, sha512_uri: installer_sha512sum_uri)
-				rescue OpenURI::HTTPError => e
-					Mmi.fail! %Q(Error when requesting fabric installer. Maybe "modloader.version" == #{version.inspect} is invalid.\n#{e.inspect})
+				if !File.exist?(installer_path) || !installer_hash.match_file?(installer_path)
+					Mmi.info "Downloading fabric-installer version #{self.version.inspect}."
+					
+					begin
+						Mmi::InstallUtils.download_to_file(installer_uri, installer_path, installer_hash)
+					rescue OpenURI::HTTPError => e
+						Mmi.fail! %Q{Error when requesting fabric installer. Maybe "modloader.version" == #{version.inspect} is invalid.\n#{e.inspect}}
+					end
+				else
+					Mmi.info "Using cached fabric-installer version #{self.version.inspect}."
 				end
 			end
 			
 			def run_installer
 				FileUtils.mkdir_p(absolute_install_dir)
 				
-				if system('java', '-jar', installer_path, self.install_type, '-dir', absolute_install_dir, '-noprofile', '-mcversion', self.mcversion, self.download_mc ? '-downloadMinecraft' : '')
+				if system('java', '-jar', installer_path, self.install_type, '-dir', absolute_install_dir, '-noprofile', '-mcversion', self.minecraft_version, self.download_minecraft ? '-downloadMinecraft' : '')
 					# Pass.
 				else
 					Mmi.fail! 'Failed to install Fabric modloader.'
@@ -111,7 +102,7 @@ module Mmi
 			
 			def available_versions
 				begin
-					Mmi::CachedDownload.download_cached(metadata_uri, metadata_path, sha512_uri: metadata_sha512sum_uri)
+					Mmi::InstallUtils.download_to_file(metadata_uri, metadata_path, Mmi::ContentHash::Sha512.new(URI.parse(metadata_sha512sum_uri).read))
 				rescue OpenURI::HTTPError => e
 					Mmi.fail! "Error when requesting available fabric installer versions.\n#{e.inspect}"
 				end

data/lib/mmi/modloader/none.rb

@@ -1,10 +1,14 @@
 module Mmi
 	module Modloader
 		class None
-			def initialize(options=nil)
+			def initialize
 				# Not installing anything requires no configuration or setup.
 			end
 			
+			def self.parse(*)
+				new
+			end
+			
 			def install
 				# Nothing to do.
 			end

data/lib/mmi/property_attributes.rb

@@ -0,0 +1,192 @@
+module Mmi
+	module PropertyAttributes
+		def initialize(hash)
+			@hash = hash
+		end
+		
+		def to_h
+			@hash
+		end
+		
+		def [](key)
+			@hash[key]
+		end
+		
+		module ClassMethods
+			PropertyConfiguration = Struct.new(:key, :type, :required, :default, :requires, :conflicts, :validate)
+			
+			def registered_properties
+				@registered_properties ||= {}
+			end
+			
+			def property(method_name, key=method_name.to_s, type: nil, required: nil, default: nil, requires: [], conflicts: [], validate: nil)
+				raise(ArgumentError, '"method_name" must be a Symbol'         ) if !method_name.is_a?(Symbol)
+				raise(ArgumentError, %Q{#{type.inspect} is not a valid "type"}) if !valid_atomic_type?(type) && !valid_hash_type?(type)
+				
+				requires  = [requires ] if !requires .is_a?(Array)
+				conflicts = [conflicts] if !conflicts.is_a?(Array)
+				
+				raise(ArgumentError, '"required" is mutually exclusive with "requires" and "conflicts"') if required && (requires.any? || conflicts.any?)
+				raise(ArgumentError, '"requires" and "conflicts" must not share entries'               ) if requires.intersect?(conflicts)
+				raise(ArgumentError, '"required" is mutually exclusive with "default"'                 ) if required && !default.nil?
+				
+				required = requires.none? && conflicts.none? && default.nil? if required.nil?
+				
+				raise(ArgumentError, '"validate" must be nil, a symbol or a Proc') if !validate.nil? && !validate.is_a?(Symbol) && !validate.is_a?(Proc)
+				
+				registered_properties[method_name] = PropertyConfiguration.new(key: key, type: type, required: required, default: default, requires: requires, conflicts: conflicts, validate: validate)
+				
+				define_method(method_name) do
+					parsed_property_store[method_name]
+				end
+			end
+			
+			def parse(hash)
+				new(hash).parse!
+			end
+			
+			def valid_atomic_type?(type)
+				type.nil? || type.respond_to?(:parse)
+			end
+			
+			def valid_hash_type?(type_hash)
+				type_hash.is_a?(Hash) && type_hash.key?(:field) && type_hash.key?(:types) && type_hash.fetch(:types).is_a?(Hash) && type_hash.fetch(:types).all? do |_, type|
+					valid_atomic_type?(type)
+				end
+			end
+		end
+		
+		def self.prepended(klass)
+			klass.extend(ClassMethods)
+		end
+		
+		def parsed_property_store
+			@parsed_property_store ||= {}
+		end
+		
+		class ValidationError < StandardError; end
+		
+		def validate_constraints!
+			errors =
+				self.class.registered_properties.map do |method_name, configuration|
+					[
+						method_name,
+						[].tap do |property_errors|
+							if configuration.required && !@hash.key?(configuration.key)
+								property_errors << "missing field #{configuration.key}"
+							elsif !configuration.required && @hash.key?(configuration.key)
+								if (missing_requires = configuration.requires.reject{ |e| @hash.key?(e) }).any?
+									property_errors << "missing required field(s) #{missing_requires.map(&:inspect).join(', ')}"
+								end
+								
+								if (present_conflicts = configuration.conflicts.select{ |e| @hash.key?(e) }).any?
+									property_errors << "conflicting with field(s) #{present_conflicts.map(&:inspect).join(', ')}"
+								end
+							end
+							
+							if @hash.key?(configuration.key) && self.class.valid_hash_type?(configuration.type)
+								if !@hash.fetch(configuration.key).is_a?(Hash)
+									property_errors << "field #{configuration.key.inspect} must be a Hash"
+								elsif !@hash.fetch(configuration.key).key?(configuration.type[:field]) || !configuration.type[:types].keys.include?(@hash.fetch(configuration.key).fetch(configuration.type[:field]))
+									property_errors << "field #{configuration.key.inspect} must have key #{configuration.type[:field].inspect} with one of values #{configuration.type[:types].keys.map(&:inspect).join(', ')}"
+								end
+							end
+							
+							if @hash.key?(configuration.key) && configuration.validate
+								deduced_proc =
+									if configuration.validate.is_a?(Symbol)
+										self.class.method(configuration.validate)
+									else
+										configuration.validate
+									end
+								
+								deduced_proc.call(@hash[configuration.key], property_errors)
+							end
+						end,
+					]
+				end.select do |_, property_errors|
+					property_errors.any?
+				end.to_h
+			
+			if errors.none?
+				true
+			else
+				raise(ValidationError, errors.map do |method_name, property_errors|
+					"#{method_name}: #{property_errors.join(', ')}"
+				end.join('; '))
+			end
+		end
+		
+		def parse!
+			validate_constraints!
+			
+			self.class.registered_properties.each do |method_name, configuration|
+				if !@hash.key?(configuration.key)
+					if configuration.required || !configuration.default.nil?
+						parsed_property_store[method_name] = configuration.default
+					else
+						# Do nothing.
+					end
+				elsif configuration.type.nil?
+					parsed_property_store[method_name] = self[configuration.key]
+				else
+					deduced_type =
+						if self.class.valid_hash_type?(configuration.type)
+							configuration.type[:types].fetch(self[configuration.key][configuration.type[:field]])
+						else
+							configuration.type
+						end
+					
+					initializer_proc = proc do |item|
+						deduced_type.parse(item)
+					end
+					
+					parsed_property_store[method_name] =
+						self[configuration.key].then do |value|
+							value.is_a?(Array) ? value.map(&initializer_proc) : initializer_proc[value]
+						end
+				end
+			end
+			
+			self
+		end
+		
+		def update_properties!(properties)
+			raise(ArgumentError, 'argument must be a Hash'                                ) if !properties.is_a?(Hash)
+			raise(ArgumentError, 'argument can only have keys that are defined properties') if (properties.keys - self.class.registered_properties.keys).any?
+			
+			old_property_store     = @parsed_property_store
+			@parsed_property_store = nil
+			
+			old_properties = properties.map do |method_name, value|
+				key = self.class.registered_properties[method_name].key
+				
+				old_value = @hash[key]
+				
+				if !value.nil?
+					@hash[key] = value
+				elsif @hash.key?(key)
+					@hash.delete(key)
+				end
+				
+				[method_name, old_value]
+			end
+			
+			parse!
+		rescue ValidationError
+			@parsed_property_store = old_property_store
+			
+			old_properties.each do |method_name, old_value|
+				key = self.class.registered_properties[method_name].key
+				
+				if !old_value.nil?
+					@hash[key] = old_value
+				elsif @hash.key?(key)
+					@hash.delete(key)
+				end
+			end
+			
+			raise
+		end
+	end
+end

data/lib/mmi/source/github.rb

@@ -2,53 +2,23 @@ require 'fileutils'
 require 'open-uri'
 
 require 'mmi/github_api'
-require 'mmi/option_attributes'
+require 'mmi/property_attributes'
 
 module Mmi
 	module Source
 		class Github
-			include Mmi::OptionAttributes
+			prepend Mmi::PropertyAttributes
 			
-			opt_accessor :owner
-			opt_accessor :repo
-			opt_accessor :install_dir
-			opt_accessor :filename
+			property :owner
+			property :repo
+			property :install_dir
+			property :filename, required: false
 			
-			opt_accessor :asset_id
-			opt_accessor :release
-			opt_accessor :file
+			property :asset_id, conflicts: %w[release file]
+			property :release,  conflicts: 'asset_id', requires: 'file'
+			property :file,     conflicts: 'asset_id', requires: 'release'
 			
-			def initialize(options)
-				@options = options
-				
-				parse!
-			end
-			
-			def parse!
-				if self.owner
-					if self.repo
-						if self.install_dir
-							if self.asset_id
-								# Pass.
-							elsif self.release
-								if self.file
-									# Pass.
-								else
-									raise Mmi::MissingAttributeError, 'Missing "source.file" from asset because "source.asset_id" is not provided.'
-								end
-							else
-								raise Mmi::MissingAttributeError, 'Missing "source.release" from asset because "source.asset_id" is not provided.'
-							end
-						else
-							raise Mmi::MissingAttributeError, 'Missing "source.install_dir" from asset.'
-						end
-					else
-						raise Mmi::MissingAttributeError, 'Missing "source.repo" from asset.'
-					end
-				else
-					raise Mmi::MissingAttributeError, 'Missing "source.owner" from asset.'
-				end
-			end
+			# TODO: Ensure that either :asset_id or [:release, :file] is given.
 			
 			def repository_url
 				"https://github.com/#{self.owner}/#{self.repo}"
@@ -66,21 +36,10 @@ module Mmi
 				end
 			end
 			
-			def install(dir)
-				install_dir = File.expand_path(self.install_dir, dir)
-				filepath    = File.join(install_dir, self.filename || (self.asset_id ? cached_asset_response.name : self.file))
-				
-				Mmi.info "Downloading #{download_url.inspect} into #{filepath.inspect}."
+			def install(install_record)
+				filepath = File.join(install_dir, self.filename || (self.asset_id ? cached_asset_response.name : self.file))
 				
-				FileUtils.mkdir_p(install_dir)
-				
-				begin
-					stream = URI.parse(download_url).open
-					
-					IO.copy_stream(stream, filepath)
-				rescue OpenURI::HTTPError => e
-					Mmi.fail! "Error when requesting asset.\n#{e.inspect}"
-				end
+				install_record.add(download_url, filepath, content_hash: nil) # As of 2024-07-18, the GitHub API does not return any hash over the asset.
 			end
 			
 			def display_name

data/lib/mmi/source/modrinth.rb

@@ -2,75 +2,42 @@ require 'fileutils'
 require 'open-uri'
 
 require 'mmi/modrinth_api'
-require 'mmi/option_attributes'
+require 'mmi/property_attributes'
+require 'mmi/content_hash/sha512'
 
 module Mmi
 	module Source
 		class Modrinth
-			include Mmi::OptionAttributes
+			prepend Mmi::PropertyAttributes
 			
-			opt_accessor :name
-			opt_accessor :version
-			opt_accessor :version_file
-			
-			opt_accessor :install_dir
-			opt_accessor :filename
-			
-			def initialize(options)
-				@options = options
-				
-				parse!
-			end
-			
-			def parse!
-				if self.name
-					if self.version
-						if self.version_file
-							if self.install_dir
-								# Pass.
-							else
-								raise Mmi::MissingAttributeError, 'Missing "source.install_dir" from asset.'
-							end
-						else
-							raise Mmi::MissingAttributeError, 'Missing "source.version_file" from asset.'
-						end
-					else
-						raise Mmi::MissingAttributeError, 'Missing "source.version" from asset.'
-					end
-				else
-					raise Mmi::MissingAttributeError, 'Missing "source.name" from asset.'
-				end
-			end
+			property :name
+			property :version
+			property :version_file
+			property :install_dir
+			property :filename, required: false
 			
 			def cached_mod_versions(loader: nil, game_version: nil)
-				(@cached_mod_versions ||= Hash.new)[{loader: loader, game_version: game_version}] ||= Mmi::ModrinthApi.project_versions(self.name, loader: loader, game_version: game_version)
+				(@cached_mod_versions ||= {})[{loader: loader, game_version: game_version}] ||= Mmi::ModrinthApi.project_versions(self.name, loader: loader, game_version: game_version)
 			end
 			
-			def download_url
+			def api_version_file
 				cached_mod_versions.select do |version|
 					version['name'] == self.version
 				end.map do |version|
 					version['files']
 				end.flatten(1).select do |files|
 					files['filename'] == self.version_file
-				end.first['url'].gsub(/ /, '%20')
+				end.first
 			end
 			
-			def install(dir)
-				install_dir = File.expand_path(self.install_dir, dir)
-				filepath    = File.join(install_dir, self.filename || self.version_file)
-				
-				Mmi.info "Downloading #{download_url.inspect} into #{filepath.inspect}."
-				
-				FileUtils.mkdir_p(install_dir)
+			def download_url
+				api_version_file['url'].gsub(/ /, '%20')
+			end
+			
+			def install(install_record)
+				filepath = File.join(install_dir, self.filename || self.version_file)
 				
-				begin
-					stream = URI.parse(download_url).open
-					
-					IO.copy_stream(stream, filepath)
-				rescue OpenURI::HTTPError => e
-					Mmi.fail! "Error when requesting asset.\n#{e.inspect}"
-				end
+				install_record.add(download_url, filepath, content_hash: Mmi::ContentHash::Sha512.new(api_version_file['hashes']['sha512']))
 			end
 			
 			def display_name

data/lib/mmi/source/url.rb

@@ -1,54 +1,25 @@
 require 'fileutils'
 require 'open-uri'
 
-require 'mmi/option_attributes'
+require 'mmi/property_attributes'
 
 module Mmi
 	module Source
 		class Url
-			include Mmi::OptionAttributes
+			prepend Mmi::PropertyAttributes
 			
-			opt_accessor :url
-			opt_accessor :install_dir
-			opt_accessor :filename
-			
-			def initialize(options)
-				@options = options
-				
-				parse!
-			end
-			
-			def parse!
-				if self.url
-					if self.install_dir
-						# Pass.
-					else
-						raise Mmi::MissingAttributeError, 'Missing "source.install_dir" from asset.'
-					end
-				else
-					raise Mmi::MissingAttributeError, 'Missing "source.name" from asset.'
-				end
-			end
+			property :url
+			property :install_dir
+			property :filename, required: false
 			
 			def download_uri
 				@download_uri ||= URI.parse(url)
 			end
 			
-			def install(dir)
-				install_dir = File.expand_path(self.install_dir, dir)
-				filepath    = File.join(install_dir, self.filename || File.basename(download_uri.path))
-				
-				Mmi.info "Downloading #{url.inspect} into #{filepath.inspect}."
-				
-				FileUtils.mkdir_p(install_dir)
+			def install(install_record)
+				filepath = File.join(install_dir, self.filename || File.basename(download_uri.path))
 				
-				begin
-					stream = download_uri.open
-					
-					IO.copy_stream(stream, filepath)
-				rescue OpenURI::HTTPError => e
-					Mmi.fail! "Error when requesting asset.\n#{e.inspect}"
-				end
+				install_record.add(url, filepath, content_hash: nil)
 			end
 			
 			def display_name

data/lib/mmi/version.rb

@@ -1,3 +1,3 @@
 module Mmi
-	VERSION = '0.2.2'.freeze
+	VERSION = '0.2.3'.freeze
 end

data/lib/mmi.rb

@@ -2,17 +2,6 @@ require 'mmi/version'
 require 'mmi/mod_file_processor'
 
 module Mmi
-	MMI_CACHE_DIR = File.join(Dir.home, '.cache', 'mmi')
-	MINECRAFT_DIR = File.join(Dir.home, '.minecraft')
-	
-	def self.cache_dir
-		MMI_CACHE_DIR
-	end
-	
-	def self.minecraft_dir
-		MINECRAFT_DIR
-	end
-	
 	class ValidationError < StandardError; end
 	class MissingAttributeError < ValidationError; end
 	class InvalidAttributeError < ValidationError; end