silkedit 0.1.0

data/lib/silkedit/savegame/crypto.rb

@@ -0,0 +1,25 @@
+require 'openssl'
+
+module Silkedit::Savegame
+  module Crypto
+    AES_KEY = YAML.safe_load_file(File.join(Silkedit::LIBDIR, 'config', 'savegame.yaml'), symbolize_names: true)[:aes_key]
+
+    def initialize(key)
+      @aes_key = key
+    end
+
+    def self.aes_encrypt(data)
+      cipher = OpenSSL::Cipher.new('AES-256-ECB')
+      cipher.encrypt
+      cipher.key = AES_KEY
+      cipher.update(data) + cipher.final
+    end
+
+    def self.aes_decrypt(data)
+      cipher = OpenSSL::Cipher.new('AES-256-ECB')
+      cipher.decrypt
+      cipher.key = AES_KEY
+      cipher.update(data) + cipher.final
+    end
+  end
+end

data/lib/silkedit/savegame/diff.rb

@@ -0,0 +1,158 @@
+require 'pp'
+
+module Silkedit::Savegame
+  module Diff
+    def self.mkdiff (old, new)
+      return { old: old, new: new } if old.class != new.class
+
+      diff = nil
+
+      if old.is_a?(Hash)
+        diff = {}
+        (old.keys + new.keys).uniq.each do |k|
+          itemdiff = mkdiff(old[k], new[k])
+          diff[k] = itemdiff unless itemdiff.nil? || itemdiff.empty?
+        end
+      elsif old.is_a?(Array)
+        diff = []
+        if old.first.is_a?(Hash)
+          if old.first.key?('Name')
+            keycomps = %w[Name]
+          elsif old.first.key?('SceneName') && old.first.key?('ID')
+            keycomps = %w[SceneName ID]
+          elsif old.first.key?('SceneName') && old.first.key?('EventType')
+            keycomps = %w[SceneName EventType]
+          else
+            keycomps = nil
+          end
+          if keycomps.nil?
+            diff = { old: old.reject { |e| new.include?(e) }, new: new.reject { |e| old.include?(e) } }
+          else
+            old.each do |o|
+              n = new.find { |e| keycomps.map { |k| e[k] == o[k] }.reduce { |a, b| a && b } }
+              itemdiff = mkdiff(
+                o.reject { |k, _v| keycomps.include?(k) },
+                n.nil? ? nil : n.reject { |k, _v| keycomps.include?(k) }
+              )
+              next if itemdiff.empty?
+              newobj = {}
+              keycomps.each { |k| newobj[k] = o[k] }
+              diff.append(newobj.merge(itemdiff))
+            end
+            new.each do |n|
+              o = old.find { |e| keycomps.map { |k| e[k] == n[k] }.reduce { |a, b| a && b } }
+              next unless o.nil?
+              itemdiff = mkdiff(
+                nil,
+                n.reject { |k, _v| keycomps.include?(k) }
+              )
+              newobj = {}
+              keycomps.each { |k| newobj[k] = n[k] }
+              diff.append(newobj.merge(itemdiff))
+            end
+          end
+        end
+      elsif old != new
+        diff = { old: old, new: new }
+      end
+      return diff
+    end
+
+    def self.parse_diff(obj, yaml_output: false)
+      if yaml_output
+        sio = StringIO.new
+        YAML.dump(obj, sio)
+        colored_string = ''
+
+        sio.string.each_line do |line|
+          i = 0
+          while i < line.length
+            blank_leadup = line[0..i-1].chars.map { |c| c == ' ' }.all?
+            if line[i] == '-' && blank_leadup
+              colored_string += line[i].colorize(:yellow)
+              i += 1
+            elsif line[i] == ':' && blank_leadup
+              j = i + line[i+1..-1].index(':')
+              colored_string += line[i..j].colorize(:magenta)
+              i += j - i + 1
+            elsif line[i].match(%r{[\"\w]}) && line[i+1..-1].include?(':')
+              j = i + line[i+1..-1].index(':')
+              colored_string += line[i..j].colorize(:red)
+              i += j - i + 1
+            elsif line[i].match(%r{\d}) && line[i..-2].chars.map { |c| c.match(%r{\d}) }.all?
+              colored_string += line[i..-2].colorize(:blue)
+              i = line.length - 1
+            elsif line[i..i + 2] == 'nil'
+              colored_string += line[i..i + 2].colorize(:yellow)
+              i += 3
+            elsif line[i..i + 3] == 'true'
+              colored_string += line[i..i + 3].colorize(:yellow)
+              i += 4
+            elsif line[i..i + 4] == 'false'
+              colored_string += line[i..i + 4].colorize(:yellow)
+              i += 5
+            elsif line[i].match(%r{[\"\w]})
+              colored_string += line[i..-2].colorize(:green)
+              i = line.length - 1
+            elsif line[i] == ':'
+              colored_string += line[i].colorize(:yellow)
+              i += 1
+            else
+              colored_string += line[i]
+              i += 1
+            end
+          end
+        end
+
+        return colored_string
+      end
+
+      sio = StringIO.new
+      PP.pp(obj, sio)
+
+      colored_string = ''
+      i = 0
+      while i < sio.string.length
+        if ['{', '}', '[', ']', ','].include?(sio.string[i])
+          colored_string += sio.string[i]
+          i += 1
+        elsif sio.string[i] == '"'
+          capture = '"'
+          cnt = 1
+          while sio.string[i + cnt] != '"'
+            capture += sio.string[i + cnt]
+            cnt += 1
+          end
+          capture += '"'
+          color = sio.string[i + cnt + 2] == '=' ? :red : :green
+          colored_string += capture.colorize(color)
+          i += cnt + 1
+        elsif sio.string[i..i + 1] == '=>'
+          colored_string += sio.string[i..i + 1].colorize(:yellow)
+          i += 2
+        elsif sio.string[i].to_i.to_s == sio.string[i]
+          colored_string += sio.string[i].colorize(:light_blue)
+          i += 1
+        elsif sio.string[i..i + 2] == 'nil'
+          colored_string += sio.string[i..i + 2].colorize(:yellow)
+          i += 3
+        elsif sio.string[i..i + 3] == 'true'
+          colored_string += sio.string[i..i + 3].colorize(:yellow)
+          i += 4
+        elsif sio.string[i..i + 4] == 'false'
+          colored_string += sio.string[i..i + 4].colorize(:yellow)
+          i += 5
+        elsif ['new:', 'old:'].include?(sio.string[i..i + 3])
+          colored_string += sio.string[i..i + 2].colorize(:magenta)
+          colored_string += sio.string[i + 3].colorize(:yellow)
+          i += 4
+        else
+          colored_string += sio.string[i]
+          i += 1
+        end
+      end
+      return colored_string
+    end
+
+  end
+end

data/lib/silkedit/savegame/packer.rb

@@ -0,0 +1,75 @@
+require 'base64'
+
+module Silkedit::Savegame
+  module Packer
+    RAWHEADER = "\u0000\u0001\u0000\u0000\u0000\xFF\xFF\xFF\xFF\u0001\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0006\u0001\u0000\u0000\u0000"
+    C_SHARP_HEADER = [0, 1, 0, 0, 0, 255, 255, 255, 255, 1, 0, 0, 0, 0, 0, 0, 0, 6, 1, 0, 0, 0]
+
+    def self.can_unpack?(string)
+      return string.start_with?(RAWHEADER)
+    end
+
+    def self.pack(string)
+      string = Crypto.aes_encrypt(string)
+      string = Base64.strict_encode64(string)
+      string = self.add_header(string)
+      string
+    end
+
+    def self.unpack(bytes)
+      bytes = self.strip_header(bytes)
+      bytes = Base64.decode64(bytes)
+      bytes = Crypto.aes_decrypt(bytes)
+      string = bytes.force_encoding('UTF-8')
+      string
+    end
+
+    def self.generate_length_prefixed_string(length)
+      length = [length, 0x7FFFFFFF].min
+      bytes = []
+      while true
+        if length >> 7 != 0
+          bytes << ((length & 0x7F) | 0x80)
+          length >>= 7
+        else
+          bytes << (length & 0x7F)
+          length >>= 7
+          break
+        end
+      end
+      bytes << length if length != 0
+      bytes.pack("C*")
+    end
+
+    def self.add_header(data)
+      # Ensure data is a binary string
+      data = data.b if data.respond_to?(:b)
+      length_data = generate_length_prefixed_string(data.bytesize)
+      result = String.new
+      result << RAWHEADER.dup.force_encoding("ASCII-8BIT")
+      result << length_data
+      result << data
+      result << [11].pack("C")
+      result
+    end
+
+    def self.strip_header(data)
+      # Remove fixed header and ending byte (11)
+      start = C_SHARP_HEADER.length
+      finish = data.bytesize - 1
+      data = data.byteslice(start...finish)
+
+      # Remove variable-length LengthPrefixedString header
+      bytes = data.bytes
+      length_count = 0
+      bytes.each do |byte|
+        length_count += 1
+        break if (byte & 0x80) == 0
+      end
+
+      # Slice off the length prefix header
+      stripped = bytes[length_count..-1] || []
+      stripped.pack("C*")
+    end
+  end
+end

data/lib/silkedit/savegame/savefile.rb

@@ -0,0 +1,153 @@
+module Silkedit::Savegame
+  class SaveFile
+    def initialize(game, savegame_index)
+      # Rbcli::Warehouse.get(:config, :parsedopts)
+      Rbcli.log.fatal('Running on unknown OS. Exiting.', exit_status: 25) if Silkedit::Sys.os.nil?
+
+      config = YAML.safe_load_file(File.join(Silkedit::LIBDIR, 'config', 'savegame.yaml'), symbolize_names: true)
+
+      @max_backups = config[:max_backups]
+      @use_yaml = config[:use_yaml]
+      @game = game
+      @data = nil
+
+      basename = "user#{savegame_index}"
+      @dirs = {
+        saves: File.expand_path(config[:savegame_directory][@game][Silkedit::Sys.os]),
+        work: File.join(Silkedit::Sys.tmpdir, @game.to_s),
+        backups: File.join(Silkedit::Sys.tmpdir, @game.to_s)
+      }
+      if @dirs[:saves].include?('%STEAMID%')
+        @dirs[:saves] = Dir.glob(File.join(File.dirname(@dirs[:saves]), '*')).select { |f| File.basename(f).match(%r{\d+}) }.first
+      end
+      @dirs.each_value { |dir| FileUtils.mkdir_p(dir) unless File.directory?(dir) }
+      @filenames = {
+        dat: File.join(@dirs[:saves], "#{basename}.dat"),
+        json: File.join(@dirs[:work], "#{basename}.#{@use_yaml ? 'yaml' : 'json'}"),
+        backup: File.join(@dirs[:backups], "#{basename}.bak")
+      }
+      @filenames[:backups] = self.get_backup_file_list
+      Rbcli.log.debug "Savegame directory: #{@dirs[:saves]}", 'SAVEGAME'
+      Rbcli.log.debug "Working directory:  #{@dirs[:work]}", 'SAVEGAME'
+    end
+
+    attr_accessor :data
+    attr_reader :dirs, :filenames, :game
+
+    def loaded?
+      !@data.nil?
+    end
+
+    def load_from_dat
+      load_from_disk(@filenames[:dat])
+      self
+    end
+
+    def save_to_dat
+      save_to_disk(@filenames[:dat], pack: true)
+      self
+    end
+
+    def load_from_json
+      load_from_disk(@filenames[:json])
+      self
+    end
+
+    def save_to_json
+      save_to_disk(@filenames[:json], pack: false)
+      self
+    end
+
+    def del_json
+      FileUtils.rm(@filenames[:json])
+      self
+    end
+
+    def load_from_backup(seq_number: nil)
+      all_backup_files = self.get_backup_file_list
+      return false if all_backup_files.empty?
+      selected_file = seq_number.nil? ? all_backup_files.last : "#{@filenames[:backup]}#{seq_number}"
+      return false unless File.exist?(selected_file)
+      load_from_disk(selected_file)
+      self
+    end
+
+    def save_to_backup(backup_name: nil)
+      if backup_name.nil?
+        return false if @max_backups <= 0
+        self.remove_old_backups
+        backup_filename = "#{@filenames[:backup]}#{self.next_backup_seq_number}"
+      else
+        backup_filename = "#{@filenames[:backup]}.#{backup_name}"
+      end
+      save_to_disk(backup_filename, pack: true)
+      backup_filename
+    end
+
+    def direct_backup(backup_name: nil)
+      if backup_name.nil?
+        return false if @max_backups <= 0
+        self.remove_old_backups
+        backup_filename = "#{@filenames[:backup]}#{self.next_backup_seq_number}"
+      else
+        backup_filename = "#{@filenames[:backup]}.#{backup_name}"
+      end
+      FileUtils.cp(@filenames[:dat], backup_filename)
+      @filenames[:backups] = self.get_backup_file_list
+      Rbcli.log.info "Backed up savefile to #{backup_filename}", 'SAVEGAME'
+      backup_filename
+    end
+
+    def direct_restore(seq_number: nil, backup_name: nil)
+      if seq_number.nil? && backup_name.nil?
+        all_backup_files = self.get_backup_file_list
+        return false if all_backup_files.empty?
+        selected_file = all_backup_files.last
+      elsif !seq_number.nil?
+        all_seq_numbers = self.get_backup_file_list.map { |f| File.extname(f).scan(/\d+$/).first }.reject(&:nil?).map { |n| n.to_i }
+        return false unless all_seq_numbers.include?(seq_number)
+        selected_file = "#{@filenames[:backup]}#{seq_number}"
+      elsif !backup_name.nil?
+        return false unless File.exist?("#{@filenames[:backup]}.#{backup_name}")
+        selected_file = "#{@filenames[:backup]}.#{backup_name}"
+      end
+      FileUtils.cp(selected_file, @filenames[:dat])
+      Rbcli.log.info "Restored savefile from #{selected_file}", 'SAVEGAME'
+      selected_file
+    end
+
+    private
+
+    def load_from_disk(filename)
+      data = File.read(filename)
+      data = Packer.unpack(data) if Packer.can_unpack?(data)
+      Rbcli.log.info "Loaded from #{File.basename(filename)}", 'SAVEGAME'
+      @data = YAML.safe_load(data)
+      # @data = JSON.parse(data)
+    end
+
+    def save_to_disk(filename, pack: false)
+      data = (@use_yaml && !pack) ? YAML.safe_dump(@data) : JSON.pretty_generate(@data)
+      data = Packer.pack(data) if pack
+      File.write(filename, data)
+      Rbcli.log.info "Saved to #{File.basename(filename)}", 'SAVEGAME'
+    end
+
+    def get_backup_file_list
+      Dir.glob("#{@filenames[:backup]}*").select { |f| f.match?(/#{File.basename(@filenames[:backup])}\d+$/) }.sort_by { |f| File.extname(f).scan(/\d+$/).first.to_i }
+    end
+
+    def remove_old_backups
+      all_backup_files = self.get_backup_file_list
+      while !all_backup_files.empty? && all_backup_files.length >= @max_backups
+        FileUtils.rm(all_backup_files.shift)
+      end
+    end
+
+    def next_backup_seq_number
+      all_backup_files = self.get_backup_file_list
+      return 0 if all_backup_files.empty?
+      all_backup_files.map { |f| File.extname(f).scan(/\d+$/).first }.reject(&:nil?).map { |n| n.to_i }.max + 1
+    end
+  end
+end

data/lib/silkedit/util/system.rb

@@ -0,0 +1,37 @@
+require 'io/console'
+
+module Silkedit::Sys
+  def self.os
+    case RbConfig::CONFIG['host_os'].to_s
+    when /mswin|msys|mingw|cygwin|bccwin|wince|windows/i
+      :windows
+    when /darwin|mac os|macos|osx/i
+      :macos
+    when /linux/i
+      :linux
+    else
+      nil
+    end
+  end
+
+  def self.tmpdir
+    case Silkedit::Sys.os
+    when :windows
+      File.join(ENV['TEMP'] || ENV['TMP'], 'silkedit')
+    when :macos
+      File.join(ENV['TMPDIR'], 'silkedit')
+    when :linux
+      File.join(ENV['TMPDIR'], 'silkedit')
+    else
+      Dir.tmpdir
+    end
+  end
+
+  def self.yes_no? question, &block
+    print "#{question} (y/n): "
+    answer = STDIN.getch.chomp.downcase until %w[y n].include?(answer)
+    print "#{answer}\n"
+    yield if block_given? && answer == 'y'
+    return answer == 'y'
+  end
+end

data/lib/silkedit/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Silkedit
+  VERSION = "0.1.0"
+end

data/lib/silkedit.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require_relative "silkedit/version"
+
+module Silkedit
+  LIBDIR = File.join(File.dirname(__FILE__), 'silkedit')
+end
+
+Dir.glob(File.join(Silkedit::LIBDIR, '**', '*.rb')).each { |file| require file }

data/sig/silkedit.rbs

@@ -0,0 +1,4 @@
+module Silkedit
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end