nauvisian 0.1.0

data/lib/nauvisian/cli/commands/mod/settings/dump.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative "../../../message_helper"
+
+module Nauvisian
+  module CLI
+    module Commands
+      module Mod
+        module Settings
+          class Dump < Dry::CLI::Command
+            include MessageHelper
+
+            desc "Dump MOD settings"
+            option :mod_directory, desc: "Directory where MODs are installed", required: false, default: Nauvisian.platform.mod_directory.to_s
+
+            def call(**options)
+              mod_directory = Pathname(options[:mod_directory])
+              mod_settings_path = mod_directory / "mod-settings.dat"
+              settings = Nauvisian::ModSettings.load(mod_settings_path)
+              puts settings.to_json
+            rescue => e
+              message(e)
+              exit 1
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/nauvisian/cli/commands/mod/versions.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require_relative "../../message_helper"
+
+module Nauvisian
+  module CLI
+    module Commands
+      module Mod
+        class Versions < Dry::CLI::Command
+          include MessageHelper
+
+          desc "List available versions of MOD"
+          argument :mod, desc: "Target MOD", required: true
+
+          def call(mod:, **)
+            api = Nauvisian::API.new
+            mod = Nauvisian::Mod[name: mod]
+            releases = api.releases(mod).sort_by(&:released_at)
+
+            releases.each do |release|
+              puts release.version
+            end
+          rescue => e
+            message(e)
+            exit 1
+          end
+        end
+      end
+    end
+  end
+end

data/lib/nauvisian/cli/commands/save/mod/list.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative "../../../lister"
+require_relative "../../../message_helper"
+
+module Nauvisian
+  module CLI
+    module Commands
+      module Save
+        module Mod
+          class List < Dry::CLI::Command
+            include MessageHelper
+
+            desc "List MODs used in the given save"
+            argument :file, desc: "Save file of a Factorio game", required: true
+            option :format, default: "plain", values: Nauvisian::CLI::Lister.all, desc: "Output format"
+
+            def call(file:, **options)
+              file_path = Pathname(file)
+              save = Nauvisian::Save.load(file_path)
+              mods = save.mods.sort
+              rows = mods.map {|mod, version| {"Name" => mod.name, "Version" => version} }
+
+              lister = Nauvisian::CLI::Lister.for(options[:format].to_sym).new(%w(Name Version))
+              lister.list(rows)
+            rescue => e
+              message(e)
+              exit 1
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/nauvisian/cli/commands/save/mod/sync.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+require_relative "../../../download_helper"
+require_relative "../../../message_helper"
+
+module Nauvisian
+  module CLI
+    module Commands
+      module Save
+        module Mod
+          class Sync < Dry::CLI::Command
+            include DownloadHelper
+            include MessageHelper
+
+            desc "Synchronize MODs and settings with the given save"
+            argument :save_file, desc: "Save file of a Factorio game", required: true
+
+            option :mod_directory, desc: "Directory where MODs are installed", required: false, default: Nauvisian.platform.mod_directory.to_s
+            option :exact, desc: "Use exact version", type: :boolean, default: false
+            option :verbose, desc: "Print extra information", type: :boolean, default: false
+
+            def call(save_file:, **options)
+              save_file_path = Pathname(save_file)
+              save = Nauvisian::Save.load(save_file_path)
+              mods_in_save = save.mods.sort # [[mod, version]]
+
+              options[:mod_directory] = Pathname(options[:mod_directory])
+              existing_mods = ExistingMods.new(**options)
+
+              downloader = Nauvisian::Downloader.new(credential: find_credential, progress: options[:verbose] ? Nauvisian::Progress::Bar : Nauvisian::Progress::Null)
+
+              mods_in_save.each do |mod, version|
+                next if mod.base?
+
+                release = existing_mods.release_to_download(mod, version)
+                next unless release
+
+                downloader.download(release, options[:mod_directory] / release.file_name)
+              end
+
+              list = Nauvisian::ModList.new(mods_in_save.map {|mod, _version| [mod, true] })
+              list.save(options[:mod_directory] / "mod-list.json")
+
+              settings = Nauvisian::ModSettings.load(options[:mod_directory] / "mod-settings.dat")
+              settings["startup"] = save.startup_settings
+              settings.save(options[:mod_directory] / "mod-settings.dat")
+            rescue => e
+              message(e)
+              exit 1
+            end
+
+            class ExistingMods
+              include DownloadHelper
+              include MessageHelper
+
+              def initialize(mod_directory:, exact:, verbose:)
+                @exact = exact
+                @verbose = verbose
+
+                zips = mod_directory.glob("*.zip")
+                directories = mod_directory.entries.select(&:directory?)
+                # [[mod, [version...]]
+                @mods = [*zips, *directories].filter_map {|path|
+                  /(?<name>.*)_(?<version>\d+\.\d+\.\d+)(?:\.zip|$)\z/ =~ path.basename.to_s && [Nauvisian::Mod[name:], Nauvisian::Version24[version]]
+                }.group_by(&:first).transform_values {|v| v.map(&:last) }.to_a
+              end
+
+              def exact? = @exact
+              def verbose? = @verbose
+
+              def release_to_download(mod, version)
+                message "⚙ Checking #{mod.name} #{version} ... "
+
+                # TODO: Take version requirement into consideration
+                case @mods
+                in [*, [^mod, [*, ^version, *]], *]
+                  message "✓ Exact version (#{version}) exists, nothing to do"
+                in [*, [^mod, [*versions]], *]
+                  if exact?
+                    message "📥 some versions are installed but exact version (#{version}) is requested"
+                    find_release(mod, version:)
+                  elsif versions.all? {|v| v < version }
+                    message "📥 all versions are older than the version in the save (#{version}), downloading the latest"
+                    find_release(mod)
+                  else
+                    message "✓ newer version exists, nothing to do"
+                  end
+                else
+                  message "📥 MOD is not installed"
+                  exact? ? find_release(mod, version:) : find_release(mod)
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/nauvisian/cli/download_helper.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Nauvisian
+  module CLI
+    module DownloadHelper
+      private def find_credential(**credential_options)
+        case credential_options
+        in {user:, token:}
+          return Nauvisian::Credential[user:, token:]
+        in {user:}
+          puts "User is specified, but token is missing"
+          exit 1
+        in {token:}
+          puts "Token is specified, but user is missing"
+          exit 1
+        else
+          Nauvisian::Credential.from_env
+        end
+      rescue KeyError
+        Nauvisian::Credential.from_player_data_file
+      end
+
+      private def find_release(mod, version: nil)
+        api = Nauvisian::API.new
+        releases = api.releases(mod)
+        if version.nil?
+          releases.max_by(&:released_at)
+        else
+          if_none = -> { puts "Version: #{version} not found"; exit 1 }
+          releases.find(if_none) {|release| release.version == version }
+        end
+      end
+    end
+  end
+end

data/lib/nauvisian/cli/lister.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require "csv"
+require "json"
+
+module Nauvisian
+  module CLI
+    class Lister
+      @listers = {}
+
+      def self.for(format)
+        @listers.fetch(format)
+      end
+
+      def self.all
+        @listers.keys.sort
+      end
+
+      def self.inherited(subclass)
+        demodulized = Nauvisian.inflector.demodulize(subclass.name)
+        underscored = Nauvisian.inflector.underscore(demodulized)
+        @listers[underscored.to_sym] = subclass
+
+        super
+      end
+
+      def initialize(headers)
+        @headers = headers
+      end
+
+      class CSV < self
+        def list(rows)
+          CSV(headers: @headers, write_headers: true) do |out|
+            rows.each do |row|
+              out << row.values_at(*@headers)
+            end
+          end
+        end
+      end
+
+      class Gfm < self
+        def list(rows)
+          puts @headers.join("|")
+          puts Array.new(@headers.length, "-").join("|")
+          rows.each do |row|
+            puts row.values_at(*@headers).join("|")
+          end
+        end
+      end
+
+      class Plain < self
+        def list(rows)
+          rows.each do |row|
+            puts row.values_at(*@headers).join(" ")
+          end
+        end
+      end
+
+      class Json < self
+        def list(rows)
+          puts rows.to_json
+        end
+      end
+    end
+  end
+end

data/lib/nauvisian/cli/message_helper.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Nauvisian
+  module CLI
+    module MessageHelper
+      private def message(exception_or_message)
+        case exception_or_message
+        in Exception
+          puts exception_or_message.message
+        in String
+          puts exception_or_message
+        else
+          raise TypeError, "must be Exception or String: %p" % message_or_exception
+        end
+      end
+    end
+  end
+end

data/lib/nauvisian/cli.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "dry/cli"
+
+require "nauvisian"
+
+require_relative "cli/commands/mod/disable"
+require_relative "cli/commands/mod/download"
+require_relative "cli/commands/mod/enable"
+require_relative "cli/commands/mod/info"
+require_relative "cli/commands/mod/installed"
+require_relative "cli/commands/mod/latest"
+require_relative "cli/commands/mod/settings/dump"
+require_relative "cli/commands/mod/versions"
+require_relative "cli/commands/save/mod/list"
+require_relative "cli/commands/save/mod/sync"
+
+module Nauvisian
+  module CLI
+    module Commands
+      extend Dry::CLI::Registry
+
+      register "mod disable", Nauvisian::CLI::Commands::Mod::Disable
+      register "mod enable", Nauvisian::CLI::Commands::Mod::Enable
+      register "mod download", Nauvisian::CLI::Commands::Mod::Download
+      register "mod info", Nauvisian::CLI::Commands::Mod::Info
+      register "mod installed", Nauvisian::CLI::Commands::Mod::Installed
+      register "mod latest", Nauvisian::CLI::Commands::Mod::Latest
+      register "mod versions", Nauvisian::CLI::Commands::Mod::Versions
+      register "mod settings dump", Nauvisian::CLI::Commands::Mod::Settings::Dump
+
+      register "save mod list", Nauvisian::CLI::Commands::Save::Mod::List
+      register "save mod sync", Nauvisian::CLI::Commands::Save::Mod::Sync
+    end
+  end
+end

data/lib/nauvisian/credential.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Nauvisian
+  Credential = Data.define(:username, :token)
+
+  class Credential
+    class << self
+      private :new
+    end
+
+    def self.from_env
+      # NOTE: values of ENV are already frozen
+      self[username: ENV.fetch("FACTORIO_SERVICE_USERNAME"), token: ENV.fetch("FACTORIO_SERVICE_TOKEN")]
+    end
+
+    def self.from_player_data_file(player_data_file_path: Nauvisian.platform.user_data_directory / "player-data.json")
+      data = JSON.load_file(player_data_file_path)
+      self[username: data["service-username"].freeze, token: data["service-token"].freeze]
+    end
+  end
+end

data/lib/nauvisian/deserializer.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module Nauvisian
+  class Deserializer
+    def initialize(stream)
+      raise ArgumentError, "can't read from the given argument" unless stream.respond_to?(:read)
+
+      @stream = stream
+    end
+
+    def read_bytes(length)
+      raise ArgumentError, "nil length" if length.nil?
+      raise ArgumentError, "negative length" if length.negative?
+      return +"" if length.zero?
+
+      bytes = @stream.read(length)
+      raise EOFError if bytes.nil? || bytes.size < length
+
+      bytes
+    end
+
+    def read_u8 = read_bytes(1).unpack1("C")
+    def read_u16 = read_bytes(2).unpack1("v")
+    def read_u32 = read_bytes(4).unpack1("V")
+
+    # https://wiki.factorio.com/Data_types#Space_Optimized
+    def read_optim_u16
+      byte = read_u8
+      byte == 0xFF ? read_u16 : byte
+    end
+
+    # https://wiki.factorio.com/Data_types#Space_Optimized
+    def read_optim_u32
+      byte = read_u8
+      byte == 0xFF ? read_u32 : byte
+    end
+
+    def read_u16_tuple(length) = Array.new(length) { read_u16 }
+    def read_optim_tuple(bit_size, length) = Array.new(length) { read_optim(bit_size) }
+
+    def read_bool = read_u8 != 0
+
+    def read_str
+      length = read_optim_u32
+      read_bytes(length).force_encoding(Encoding::UTF_8)
+    end
+
+    # https://wiki.factorio.com/Property_tree#String
+    def read_str_property = read_bool ? "" : read_str
+
+    # https://wiki.factorio.com/Property_tree#Number
+    def read_double = read_bytes(8).unpack1("d")
+
+    # Assumed: method arguments are evaluated from left to right but...
+    # https://stackoverflow.com/a/36212870/16014712
+
+    def read_version64 = Nauvisian::Version64[read_u16, read_u16, read_u16, read_u16]
+
+    def read_version24 = Nauvisian::Version24[read_optim_u16, read_optim_u16, read_optim_u16]
+
+    # https://wiki.factorio.com/Property_tree#List
+    def read_list
+      length = read_optim_u32
+      Array(length) { read_property_tree }
+    end
+
+    # https://wiki.factorio.com/Property_tree#Dictionary
+    def read_dictionary
+      length = read_u32
+      length.times.each_with_object({}) do |_i, dict|
+        key = read_str_property
+        dict[key] = read_property_tree
+      end
+    end
+
+    def read_property_tree
+      type = read_u8
+      _any_type_flag = read_bool
+
+      case type
+      when 1
+        read_bool
+      when 2
+        read_double
+      when 3
+        read_str_property
+      when 4
+        read_list
+      when 5
+        read_dictionary
+      else
+        raise Nauvisian::UnknownPropertyType, type
+      end
+    end
+  end
+end

data/lib/nauvisian/downloader.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require "digest/sha1"
+require "open-uri"
+
+require "rack/utils"
+
+module Nauvisian
+  class Downloader
+    def initialize(credential:, progress: Nauvisian::Progress::Null)
+      @credential = credential
+      @progress_class = progress
+      @cache = Nauvisian::Cache::FileSystem.new(name: "download", ttl: Float::INFINITY)
+    end
+
+    def download(release, output_path)
+      with_error_handling(release) do
+        @progress = @progress_class.new(release)
+        url = release.download_url.dup
+        url.query = Rack::Utils.build_nested_query(@credential.to_h)
+        data = @cache.fetch(url) { get(url) }
+        File.binwrite(output_path, data)
+        raise Nauvisian::DigestMismatch unless Digest::SHA1.file(output_path) == release.sha1
+      end
+    end
+
+    private def with_error_handling(release)
+      yield
+    rescue OpenURI::HTTPError => e
+      case e.io.status
+      in ["404", _]
+        raise Nauvisian::ModNotFound, release.mod
+      else
+        raise Nauvisian::Error
+      end
+    end
+
+    private def get(url)
+      url.open(content_length_proc: method(:set_total), progress_proc: method(:update_progress)) do |io|
+        case io.content_type
+        when "application/octet-stream"
+          return io.read
+        else # login requested
+          raise Nauvisian::AuthError, io.status[1]
+        end
+      end
+    end
+
+    private def set_total(total) # rubocop:disable Naming/AccessorMethodName
+      @progress.total = total if total
+    end
+
+    private def update_progress(progress)
+      @progress.progress = progress
+    end
+  end
+end

data/lib/nauvisian/error.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Nauvisian
+  class Error < StandardError; end
+
+  class ModNotFound < Error
+    def initialize(mod) = super "Mod not found: #{mod.name}"
+  end
+
+  class AuthError < Error; end
+  class APIError < Error; end
+  class DigestMismatch < Error; end
+  class UnsupportedPlatform < Error; end
+  class UnsupportedVersion < Error; end
+  class UnknownPropertyType < Error; end
+end

data/lib/nauvisian/mod/detail.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Nauvisian
+  class Mod
+    Detail = Data.define(:downloads_count, :name, :owner, :summary, :title, :category, :created_at, :description)
+
+    class Detail
+      def url = (URI("https://mods.factorio.com/mod/") + name).freeze
+
+      class << self
+        private :new
+      end
+    end
+  end
+end

data/lib/nauvisian/mod/release.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Nauvisian
+  class Mod
+    Release = Data.define(:mod, :download_url, :file_name, :released_at, :version, :sha1)
+
+    class Release
+      class << self
+        private :new
+      end
+    end
+  end
+end

data/lib/nauvisian/mod.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Nauvisian
+  Mod = Data.define(:name) do
+    include Comparable
+
+    def base?
+      name == "base"
+    end
+
+    def to_s = name
+
+    def <=>(other)
+      (base? && (other.base? ? 0 : -1)) || (other.base? ? 1 : name.casecmp(other.name))
+    end
+  end
+end
+
+require_relative "mod/detail"
+require_relative "mod/release"

data/lib/nauvisian/mod_list.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Nauvisian
+  class ModList
+    DEFAULT_MOD_LIST_PATH = Nauvisian.platform.mod_directory / "mod-list.json"
+    private_constant :DEFAULT_MOD_LIST_PATH
+
+    include Enumerable
+
+    def self.load(from=DEFAULT_MOD_LIST_PATH)
+      raw_data = JSON.parse(File.read(from), symbolize_names: true)
+      new(raw_data[:mods].to_h {|e| [Mod[name: e[:name]], e[:enabled]] })
+    end
+
+    def initialize(mods={})
+      @mods = {Nauvisian::Mod[name: "base"] => true}
+      mods.each do |mod, enabled|
+        next if mod.base?
+
+        @mods[mod] = enabled
+      end
+    end
+
+    def save(to=DEFAULT_MOD_LIST_PATH)
+      File.write(to, JSON.pretty_generate({mods: @mods.map {|mod, enabled| {name: mod.name, enabled:} }}))
+    end
+
+    def each
+      return @mods.to_enum unless block_given?
+
+      @mods.each do |mod, enabled|
+        yield(mod, enabled)
+      end
+    end
+
+    def add(mod, enabled: nil)
+      raise ArgumentError, "Can't disable the base mod" if mod.base? && enabled == false
+
+      @mods[mod] = enabled.nil? ? true : enabled
+    end
+
+    def remove(mod)
+      raise ArgumentError, "Can't remove the base mod" if mod.base?
+
+      @mods.delete(mod)
+    end
+
+    def exist?(mod) = @mods.key?(mod)
+
+    def enabled?(mod)
+      raise Nauvisian::ModNotFound, mod unless exist?(mod)
+
+      @mods[mod]
+    end
+
+    def enable(mod)
+      raise Nauvisian::ModNotFound, mod unless exist?(mod)
+
+      @mods[mod] = true
+    end
+
+    def disable(mod)
+      raise ArgumentError, "Can't disalbe the base mod" if mod.base?
+      raise Nauvisian::ModNotFound, mod unless exist?(mod)
+
+      @mods[mod] = false
+    end
+  end
+end