nauvisian 0.1.0

data/lib/nauvisian/mod_settings.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Nauvisian
+  class ModSettings
+    DEFAULT_MOD_SETTINGS_PATH = Nauvisian.platform.mod_directory / "mod-settings.dat"
+    private_constant :DEFAULT_MOD_SETTINGS_PATH
+
+    def self.load(from=DEFAULT_MOD_SETTINGS_PATH)
+      File.open(from, "rb") do |stream|
+        des = Nauvisian::Deserializer.new(stream)
+        version = des.read_version64
+        _unused = des.read_bool
+        properties = des.read_property_tree
+        new(version:, properties:)
+      end
+    end
+
+    def initialize(version:, properties:)
+      @version = version
+      @properties = properties
+    end
+
+    def save(to=DEFAULT_MOD_SETTINGS_PATH)
+      File.open(to, "wb") do |stream|
+        ser = Nauvisian::Serializer.new(stream)
+        ser.write_version64(@version)
+        ser.write_bool(false)
+        ser.write_property_tree(@properties)
+      end
+    end
+
+    def [](key)
+      @properties[key]
+    end
+
+    def []=(key, properties)
+      @properties[key] = properties
+    end
+
+    def to_json(*args)
+      JSON.generate(@properties.merge(version: @version), *args)
+    end
+  end
+end

data/lib/nauvisian/platform.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require "pathname"
+require "rbconfig"
+
+module Nauvisian
+  class Platform
+    def self.platform
+      host_os = RbConfig::CONFIG["host_os"]
+      case host_os
+      when /\bdarwin\d*\b/
+        MacOS.new
+      when /\blinux\z/
+        Linux.new
+      when /\b(?:cygwin|mswin|mingw|bccwin|wince|emx)\b/
+        Windows.new
+      else
+        raise UnsupportedPlatform, host_os
+      end
+    end
+
+    def mod_directory = user_data_directory / "mods"
+
+    def save_directory = user_data_directory / "saves"
+
+    def script_output_directory = user_data_directory / "script-output"
+
+    # Returns the directory which holds user data
+    def user_data_directory
+      raise NotImplementedError
+    end
+
+    def application_directory
+      APPLICATON_DIRECTORIES.find(&:directory?)
+    end
+
+    def home_directory
+      Pathname("~").expand_path.freeze
+    end
+
+    class MacOS < self
+      def user_data_directory
+        Pathname("~/Library/Application Support/Factorio").expand_path.freeze
+      end
+
+      APPLICATON_DIRECTORIES = [
+        Pathname("~/Library/Application Support/Steam/steamapps/common/Factorio/factorio.app/Contents").freeze,
+        Pathname("/Applications/factorio.app/Contents").freeze
+      ].freeze
+      private_constant :APPLICATON_DIRECTORIES
+    end
+
+    class Linux < self
+      def user_data_directory
+        Pathname("~/.factorio").expand_path.freeze
+      end
+
+      def application_directory
+        Pathname("~/.factorio").expand_path.freeze
+      end
+    end
+
+    class Windows < self
+      def user_data_directory
+        (Pathname(ENV.fetch("APPDATA")).expand_path / "Factorio").freeze
+      end
+
+      def home_directory
+        Pathname(ENV.fetch("USERPROFILE")).expand_path.freeze
+      end
+
+      APPLICATON_DIRECTORIES = [].freeze
+      APPLICATON_DIRECTORIES << Pathname("#{ENV.fetch("PROGRAMFILES(x86)")}\\Steam\\steamapps\\common\\Factorio").freeze if ENV.key?("PROGRAMFILES(x86)")
+      APPLICATON_DIRECTORIES << Pathname("#{ENV.fetch("PROGRAMFILES")}\\Factorio").freeze if ENV.key?("PROGRAMFILES")
+      private_constant :APPLICATON_DIRECTORIES
+    end
+  end
+end

data/lib/nauvisian/progress/bar.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require "ruby-progressbar"
+
+module Nauvisian
+  module Progress
+    class Bar
+      FORMAT = "%t|%B|%J%%|"
+      private_constant :FORMAT
+
+      def initialize(release)
+        @progress_bar = ProgressBar.create(title: "⚙ %s" % release.file_name, format: FORMAT)
+      end
+
+      def progress=(progress)
+        @progress_bar.progress = progress
+      end
+
+      def total=(total)
+        @progress_bar.total = total
+      end
+    end
+  end
+end

data/lib/nauvisian/progress/null.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Nauvisian
+  module Progress
+    class Null
+      def initialize(_release)
+        # do nothing
+      end
+
+      def progress=(_progress)
+        # do nothing
+      end
+
+      def total=(_total)
+        # do nothing
+      end
+    end
+  end
+end

data/lib/nauvisian/progress.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require_relative "progress/bar"
+require_relative "progress/null"

data/lib/nauvisian/save.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require "zlib"
+
+require "zip"
+
+module Nauvisian
+  Save = Data.define(:version, :mods, :startup_settings)
+
+  class Save
+    LEVEL_FILE_NAMES = %w(level.dat0 level-init.dat).freeze
+    private_constant :LEVEL_FILE_NAMES
+
+    LEVEL_FILE_NAMES_GLOB = File.join("*", "level{.dat0,-init.dat}")
+    private_constant :LEVEL_FILE_NAMES_GLOB
+
+    def self.load(zip_path)
+      stream = stream(zip_path)
+      des = Nauvisian::Deserializer.new(stream)
+
+      new(**populate(des))
+    end
+
+    class << self
+      private :new
+
+      private def stream(zip_path)
+        Zip::File.open(zip_path) do |zip_file|
+          candidate_entries = zip_file.glob(LEVEL_FILE_NAMES_GLOB)
+          LEVEL_FILE_NAMES.each do |file_name|
+            candidate_entries.each do |entry|
+              next unless File.basename(entry.name) == file_name
+
+              stream = entry.get_input_stream
+              # ZLIB Compressed Data Format Specification version 3.3
+              # 2.2 Data Format https://www.rfc-editor.org/rfc/rfc1950#section-2.2
+              cmf = stream.read(1).unpack1("C")
+              stream.rewind
+              # 32K window, deflate
+              return cmf == 0x78 ? StringIO.new(Zlib.inflate(stream.read)) : stream # level.dat0 : level-init.dat
+            end
+          end
+          raise Errno::ENOENT, "level.dat0 or level-init.dat not found"
+        end
+      end
+
+      private def populate(des)
+        version = des.read_version64
+        raise Nauvisian::UnsupportedVersion if version < Nauvisian::Version64[1, 0, 0, 0]
+
+        des.read_u8 # skip a byte
+
+        # Some values are out of concern
+        _campaign = des.read_str
+        _level_name = des.read_str
+        _base_mod = des.read_str
+        _difficulty = des.read_u8
+        _finished = des.read_bool
+        _player_won = des.read_bool
+        _next_level = des.read_str
+        _can_continue = des.read_bool
+        _finished_but_continuing = des.read_bool
+        _saving_replay = des.read_bool
+        _allow_non_admin_debug_options = des.read_bool
+        _loaded_from = des.read_version24
+        _loaded_from_build = des.read_u16
+        _allowed_commands = des.read_u8
+
+        mods = read_mods(des)
+
+        _unknown_4_bytes = des.read_bytes(4) # example: fPK\t (0x66 0x50 0x4B 0x09)
+        startup_settings = des.read_property_tree
+
+        {version:, mods:, startup_settings:}
+      end
+
+      private def read_mod(des)
+        mod = Nauvisian::Mod[name: des.read_str.freeze]
+        version = des.read_version24
+        _crc = des.read_u32.freeze
+        [mod, version]
+      end
+
+      private def read_mods(des) = Array.new(des.read_optim_u32) { read_mod(des) }.to_h.freeze
+    end
+  end
+end
+
+require_relative "deserializer"

data/lib/nauvisian/serializer.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module Nauvisian
+  class Serializer
+    def initialize(stream)
+      raise ArgumentError, "can't read from the given argument" unless stream.respond_to?(:write)
+
+      @stream = stream
+    end
+
+    def write_bytes(data)
+      raise ArgumentError if data.nil?
+      return if data.empty?
+
+      @stream.write(data)
+    end
+
+    def write_u8(uint8) = write_bytes([uint8].pack("C"))
+    def write_u16(uint16) = write_bytes([uint16].pack("v"))
+    def write_u32(uint32) = write_bytes([uint32].pack("V"))
+
+    # https://wiki.factorio.com/Data_types#Space_Optimized
+    def write_optim_u16(uint16)
+      if uint16 < 0xFF
+        write_u8(uint16 & 0xFF)
+      else
+        write_u8(0xFF)
+        write_u16(uint16)
+      end
+    end
+
+    # https://wiki.factorio.com/Data_types#Space_Optimized
+    def write_optim_u32(uint32)
+      if uint32 < 0xFF
+        write_u8(uint32 & 0xFF)
+      else
+        write_u8(0xFF)
+        write_u32(uint32)
+      end
+    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 write_bool(bool) = write_u8(bool ? 0x01 : 0x00)
+
+    def write_str(str)
+      write_optim_u32(str.length)
+      write_bytes(str.b)
+    end
+
+    # https://wiki.factorio.com/Property_tree#String
+    def write_str_property(str)
+      if str.empty?
+        write_bool(true)
+      else
+        write_bool(false)
+        write_str(str)
+      end
+    end
+
+    # https://wiki.factorio.com/Property_tree#Number
+    def write_double(dbl) = write_bytes([dbl].pack("d"))
+
+    def write_version64(v64) = v64.to_a.each {|u16| write_u16(u16) }
+
+    def write_version24(v24) = v24.to_a.each {|u16| write_optim_u16(u16) }
+
+    # https://wiki.factorio.com/Property_tree#List
+    def write_list(list)
+      write_optim_u32(list.size)
+      list.each {|e| write_property_tree(e) }
+    end
+
+    # https://wiki.factorio.com/Property_tree#Dictionary
+    def write_dictionary(dict)
+      write_u32(dict.size)
+      dict.each do |(key, value)|
+        write_str_property(key)
+        write_property_tree(value)
+      end
+    end
+
+    def write_property_tree(obj)
+      case obj
+      in true | false => bool
+        write_u8(1)
+        write_bool(false)
+        write_bool(bool)
+      in Float => dbl
+        write_u8(2)
+        write_bool(false)
+        write_double(dbl)
+      in String => str
+        write_u8(3)
+        write_bool(false)
+        write_str_property(str)
+      in Array => list
+        write_u8(4)
+        write_bool(false)
+        write_list(list)
+      in Hash => dict
+        write_u8(5)
+        write_bool(false)
+        write_dictionary(dict)
+      else
+        raise Nauvisian::UnknownPropertyType, obj.class
+      end
+    end
+  end
+end

data/lib/nauvisian/uri/s3.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require "uri"
+
+module Nauvisian
+  module URI
+    class S3 < ::URI::Generic
+      DEFAULT_PORT = nil
+      private_constant :DEFAULT_PORT
+
+      def key = path.delete_prefix("/").freeze
+
+      def key=(key)
+        self.path = "/#{key}"
+      end
+
+      alias bucket host
+    end
+  end
+end
+
+URI.register_scheme "S3", Nauvisian::URI::S3

data/lib/nauvisian/version.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Nauvisian
+  VERSION = "0.1.0"
+  public_constant :VERSION
+end

data/lib/nauvisian/version24.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Nauvisian
+  class Version24
+    include Comparable
+
+    UINT8_MAX = (2**8) - 1
+    private_constant :UINT8_MAX
+
+    def initialize(*args)
+      case args
+      in [String] if /\A(\d+)\.(\d+)\.(\d+)\z/ =~ args[0]
+        @version = [Integer($1), Integer($2), Integer($3)]
+      in [Integer, Integer, Integer] if args.all? {|e| e.is_a?(Numeric) && e.integer? && e.between?(0, UINT8_MAX) }
+        @version = args
+      else
+        raise ArgumentError, "Expect version string or 3-tuple: %p" % [args]
+      end
+      @version.freeze
+      freeze
+    end
+
+    class << self
+      alias [] new
+    end
+
+    protected attr_reader :version
+
+    def to_s = "%d.%d.%d" % @version
+    def to_a = @version.dup.freeze
+    def <=>(other) = @version <=> other.version
+  end
+end

data/lib/nauvisian/version64.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Nauvisian
+  class Version64
+    include Comparable
+
+    UINT16_MAX = (2**16) - 1
+    private_constant :UINT16_MAX
+
+    def initialize(*args)
+      case args
+      in [String] if /\A(\d+)\.(\d+)\.(\d+)(?:-(\d+))?\z/ =~ args[0]
+        @version = [Integer($1), Integer($2), Integer($3), $4.nil? ? 0 : Integer($4)]
+      in [Integer, Integer, Integer, Integer] if args.all? {|e| e.is_a?(Numeric) && e.integer? && e.between?(0, UINT16_MAX) }
+        @version = args
+      else
+        raise ArgumentError, "Expect version string or 4-tuple: %p" % [args]
+      end
+      @version.freeze
+      freeze
+    end
+
+    class << self
+      alias [] new
+    end
+
+    protected attr_reader :version
+
+    def to_s = "%d.%d.%d-%d" % @version
+    def to_a = @version.dup.freeze
+    def <=>(other) = @version <=> other.version
+  end
+end

data/lib/nauvisian.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require "dry/inflector"
+
+require_relative "nauvisian/error"
+
+require_relative "nauvisian/api"
+require_relative "nauvisian/credential"
+require_relative "nauvisian/deserializer"
+require_relative "nauvisian/downloader"
+require_relative "nauvisian/mod"
+require_relative "nauvisian/platform"
+require_relative "nauvisian/progress"
+require_relative "nauvisian/save"
+require_relative "nauvisian/serializer"
+require_relative "nauvisian/version"
+require_relative "nauvisian/version24"
+require_relative "nauvisian/version64"
+
+module Nauvisian
+  def self.inflector
+    @inflector ||= Dry::Inflector.new
+  end
+
+  def self.platform
+    @platform ||= Nauvisian::Platform.platform
+  end
+end
+
+# some class must be loaded after definine Nauvisian::Platform.platform
+require_relative "nauvisian/cache"
+require_relative "nauvisian/mod_list"
+require_relative "nauvisian/mod_settings"

data/nauvisian.gemspec

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require_relative "lib/nauvisian/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "nauvisian"
+  spec.version = Nauvisian::VERSION
+  spec.authors = ["OZAWA Sakuro"]
+  spec.email = ["10973+sakuro@users.noreply.github.com"]
+
+  spec.summary = "A library for managing Factorio MODs"
+  spec.description = <<~DESC
+    Nauvisian is a ruby library for the management of Factorio MODs.
+
+    It comes with a CLI.
+  DESC
+  spec.homepage = "https://github.com/sakuro/nauvisian"
+  spec.license = "MIT"
+  spec.required_ruby_version = ">= 3.2.0"
+
+  spec.metadata["allowed_push_host"] = "https://rubygems.org"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://github.com/sakuro/nauvisian.git"
+  spec.metadata["changelog_uri"] = "https://github.com/sakuro/nauvisian/blob/main/CHANGELOG.md"
+  spec.metadata["rubygems_mfa_required"] = "true"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(__dir__) do
+    %x[git ls-files -z].split("\x0").reject do |f|
+      (f == __FILE__) || f.match(%r{\A(?:(?:bin|test|spec|features)/|\.(?:git|circleci)|appveyor)})
+    end
+  end
+  spec.bindir = "exe"
+  spec.executables = spec.files.grep(%r{\Aexe/}) {|f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "aws-sdk-s3", "~> 1.0"
+  spec.add_dependency "dry-cli", "~> 1.0"
+  spec.add_dependency "dry-inflector", "~> 1.0"
+  spec.add_dependency "rack", "~> 3.0"
+  spec.add_dependency "ruby-progressbar", "~> 1.11"
+  spec.add_dependency "rubyzip", "~> 2.3"
+end