rbstarbound 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: bc2319a0b69674dfcdccfd64791c37858fecc10f
-  data.tar.gz: 7fe512695536fd226115bc2116786145865f71c2
+  metadata.gz: d05f85c2aa5f0cfb19c28e8d45f9c378da343273
+  data.tar.gz: 2be0f43338decdda10062f93a5f0018e4db6f33e
 SHA512:
-  metadata.gz: 8a1fe19f1faa35fdaabe9e0bcd0ff1c2ba8f6cd9adb9f5a298efe9c15ced2c9596c02bcf2057e3750cd6f26c4e7f51f74a9522b5f23650fe307f31d5211fb38e
-  data.tar.gz: 86452ce8a5f13cd43bcdec1b217bcd7992a634226dfde90c8ae9dd405e39e618b84286da2902f4f5a90d81198c5161306abb6245e94e7eeae42d42d5eabee223
+  metadata.gz: 9cc42be3a1e207957bac7e4252572e0b1a764f10c40959b1e0a6275291e3123ed0b3ca6b225fb54f629a6ffd43cb3e0fa4513f08320a053d0d5e85d05550e1dc
+  data.tar.gz: 181f76077841725a6f27e916b7b7c8f4892bd4b7dfab3ae6cf2080ce54052930cd6294d20e97007d45e3cec60a51ce9fe20ae5e0e0c7b51b6ed2a9d69335a0a6

data/README.md

@@ -9,7 +9,10 @@ Frankly, it's just a ruby version of
 All thanks to
 [blixt](https://github.com/blixt).
 
---------------------------------------------------------------------------------
+Also, see
+[changelog
+](https://github.com/JetPirate/rb-starbound/blob/master/changelog.yaml)
+to know what's new.
 ## Installation
 
 #### I. option
@@ -43,11 +46,16 @@ You just
 
 To get YAML file with all parsed player data:
 
-**Attention: will be changed!**
+    $ ./bin/rbstarbound dump -f yaml -i path/to/save/file -o path/to/output/file
+
+For more see:
+
+    $ ./bin/rbstarbound --help
+
 
-    $ ./bin/rbstarbound path/to/save/file path/to/output/file
+with installed as a gem you could use (from any folder):
 
-... will be added ...
+    $ rbstarbound --help
 
 ### with the gem/library
 
@@ -66,7 +74,8 @@ puts player['data']['identity']['name']
 
 ```
 
-... will be added ...
+For more see:
+https://github.com/JetPirate/rb-starbound/blob/master/examples
 
 --------------------------------------------------------------------------------
 

data/bin/rbstarbound

@@ -1,12 +1,5 @@
 #!/usr/bin/env ruby
 
 require 'rbstarbound'
-require 'yaml'
-unless ARGV.count == 2
-  puts 'You need to input file paths'
-  return
-end
-player = RBStarbound.parse_player_save_file(ARGV[0].to_s)
-File.open(ARGV[1].to_s, 'w') do |file|
-  file.write(player['data'].to_yaml)
-end
+
+exit RBStarbound::MainCommand.run || RBStarbound::EX_OK

data/lib/rbstarbound/commands/dump.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module RBStarbound
+  class DumpCommand < Clamp::Command
+    option ['-f', '--format'], 'FORMAT', 'file\'s output format; one of: yaml',
+           required: true
+    option ['-i', '--save-file'], 'FILE',
+           'file to fetch player data from',
+           required: true
+    option ['-o', '--formatted-file'], 'FILE', 'file to save player data to',
+           required: true
+
+    def execute
+      return unless format.casecmp('yaml').zero?
+      dump_to_yaml(save_file.to_s, formatted_file.to_s)
+    end
+
+    private
+
+    def dump_to_yaml(input, output)
+      player_data = RBStarbound.parse_player_save_file(input.to_s)
+      return RBStarbound::EX_ERR if player_data.nil?
+      begin
+        formatted_file = File.open(output, 'w')
+        formatted_file.write(player_data['data'].to_yaml)
+        return RBStarbound::EX_OK
+      rescue StandardError => e
+        RBStarbound.print_error(e)
+        return RBStarbound::EX_ERR
+      ensure
+        formatted_file.close unless formatted_file.nil?
+      end
+    end
+  end
+end

data/lib/rbstarbound/commands/serialize.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require 'yaml'
+
+module RBStarbound
+  class SerializeCommand < Clamp::Command
+    option ['-f', '--format'], 'FORMAT', 'file\'s input format; one of: yaml',
+           required: true
+    option ['-i', '--formatted-file'], 'FILE',
+           'file to fetch player data from',
+           required: true
+    option ['-o', '--save-file'], 'FILE', 'file to save player data to',
+           required: true
+
+    def execute
+      return unless format.casecmp('yaml').zero?
+      serialize_from_yaml(formatted_file.to_s, save_file.to_s)
+    end
+
+    private
+
+    def serialize_from_yaml(input, output)
+      formatted_file = File.open(input)
+      fetched_data = YAML.load(formatted_file)
+      player_data = RBStarbound::Player::Data.new(
+        RBStarbound::Player::DATA_NAME,
+        RBStarbound::Player::DATA_VERSION,
+        fetched_data
+      )
+      dumped = RBStarbound.dump_player_save_file(output, player_data)
+      return dumped ? RBStarbound::EX_OK : RBStarbound::EX_ERR
+    rescue StandardError => e
+      RBStarbound.print_error(e)
+      return RBStarbound::EX_ERR
+    ensure
+      formatted_file.close unless formatted_file.nil?
+    end
+  end
+end

data/lib/rbstarbound/exit_codes.rb

@@ -0,0 +1,4 @@
+module RBStarbound
+  EX_OK = 0
+  EX_ERR = 1
+end

data/lib/rbstarbound/main_command.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'clamp'
+require 'rbstarbound/exit_codes'
+require 'rbstarbound/commands/dump'
+require 'rbstarbound/commands/serialize'
+
+module RBStarbound
+  class MainCommand < Clamp::Command
+    option '--version', :flag, 'show version' do
+      puts RBStarbound::VERSION
+      exit RBStarbound::EX_OK
+    end
+
+    subcommand 'dump',
+               'dump a player save file as a formatted file',
+               RBStarbound::DumpCommand
+    subcommand 'serialize',
+               'serialize a player save file form a formatted file',
+               RBStarbound::SerializeCommand
+  end
+end

data/lib/rbstarbound/player.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module RBStarbound
+  module Player
+    DATA_NAME = 'PlayerEntity'
+    DATA_VERSION = 30
+    Data = Struct.new(:name, :version, :data) do
+      def player_name; data['identity']['name'];               end
+      def player_name=(name); data['identity']['name'] = name; end
+      def gender; data['identity']['gender'];                  end
+      def gender=(value); data['identity']['gender'] = value;  end
+      def hair_type; data['identity']['hairType'];               end
+      def hair_type=(type); data['identity']['hairType'] = type; end
+      def personality; data['identity']['personalityIdle'];                 end
+      def personality=(value); data['identity']['personalityIdle'] = value; end
+      def death_count; data['identity']['deathCount'];                      end
+      def death_count=(count); data['identity']['deathCount'] = count;      end
+      def play_time; data['identity']['playTime']; end
+      def uuid; data['identity']['uuid'];          end
+      def intro_complete?; data['identity']['introComplete'];              end
+      def intro_complete=(bool); data['identity']['introComplete'] = bool; end
+      def ship_level; data['identity']['shipLevel'];                 end
+      def ship_level=(level); data['identity']['shipLevel'] = level; end
+    end
+  end
+end

data/lib/rbstarbound/sbon.rb

@@ -11,6 +11,16 @@ module RBStarbound
       end
     end
 
+    def self.write_varint(io, value)
+      buf = (value & 0b01_11_11_11).chr
+      value >>= 7
+      until value.zero?
+        buf = (value & 0b01_11_11_11 | 0b10_00_00_00).chr + buf
+        value >>= 7
+      end
+      io.write(buf)
+    end
+
     def self.read_varint_signed(io)
       value = read_varint(io)
       # Least significant bit represents the sign.
@@ -18,15 +28,32 @@ module RBStarbound
       value >> 1
     end
 
+    def self.write_varint_signed(io, value)
+      if value < 0
+        write_varint(io, (-(value + 1) << 1 | 1))
+      else
+        write_varint(io, value << 1)
+      end
+    end
+
     def self.read_bytes(io)
       length = read_varint(io)
       io.read(length)
     end
 
+    def self.write_bytes(io, data)
+      write_varint(io, data.length)
+      io.write(data)
+    end
+
     def self.read_string(io)
       read_bytes(io)
     end
 
+    def self.write_string(io, data)
+      write_bytes(io, data)
+    end
+
     def self.read_list(io)
       list = []
       read_varint(io).times do
@@ -35,6 +62,13 @@ module RBStarbound
       list
     end
 
+    def self.write_list(io, list)
+      write_varint(io, list.length)
+      list.each do |item|
+        write_dynamic(io, item)
+      end
+    end
+
     def self.read_map(io)
       map = {}
       read_varint(io).times do
@@ -44,25 +78,114 @@ module RBStarbound
       map
     end
 
+    def self.write_map(io, map)
+      write_varint(io, map.length)
+      map.each_pair do |key, val|
+        write_string(io, key)
+        write_dynamic(io, val)
+      end
+    end
+
     def self.read_dynamic(io)
-      case read_ord(io)
-      when 1 then nil # nil value
-      when 2 then io.read(8).unpack('G')[0] # double; big-endian
-      when 3 then !read_ord(io).zero? # boolean value
-      when 4 then read_varint_signed(io) # VLQ; signed
-      when 5 then read_string(io) # string value
-      when 6 then read_list(io) # list value (array)
-      when 7 then read_map(io) # map value (hash)
+      case read_data_type(io)
+      when 1 then read_nil(io)
+      when 2 then read_double(io) # big-endian
+      when 3 then read_bool(io)
+      when 4 then read_integer(io) # VLQ; signed
+      when 5 then read_str(io)
+      when 6 then read_array(io)
+      when 7 then read_hash(io)
       else raise RBStarbound::ValueError, 'Unknown dynamic type'
       end
     end
 
-    def self.read_ord(io)
+    def self.write_dynamic(io, data)
+      case data
+      when nil                   then write_nil(io)
+      when Float                 then write_double(io, data)
+      when TrueClass, FalseClass then write_bool(io, data)
+      when Integer               then write_integer(io, data)
+      when String                then write_str(io, data)
+      when Array                 then write_array(io, data)
+      when Hash                  then write_hash(io, data)
+      else raise ValueError, 'Cannot write value'
+      end
+    end
+
+    def self.read_data_type(io)
       io.readchar.ord
     end
 
+    def self.read_bool(io)
+      !read_data_type(io).zero?
+    end
+
+    def self.write_bool(io, value)
+      if value.is_a? TrueClass
+        io.write("\x03\x01".b)
+      else
+        io.write("\x03\x00".b)
+      end
+    end
+
+    def self.read_double(io)
+      io.read(8).unpack('G').first
+    end
+
+    def self.write_double(io, value)
+      io.write("\x02".b)
+      io.write([value].pack('G'))
+    end
+
+    def self.read_integer(io)
+      read_varint_signed(io)
+    end
+
+    def self.write_integer(io, data)
+      io.write("\x04".b)
+      write_varint_signed(io, data)
+    end
+
+    def self.read_str(io)
+      read_string(io)
+    end
+
+    def self.write_str(io, data)
+      io.write("\x05".b)
+      write_string(io, data)
+    end
+
+    def self.read_array(io)
+      read_list(io)
+    end
+
+    def self.write_array(io, data)
+      io.write("\x06".b)
+      write_list(io, data)
+    end
+
+    def self.read_hash(io)
+      read_map(io)
+    end
+
+    def self.write_hash(io, data)
+      io.write("\x07".b)
+      write_map(io, data)
+    end
+
+    def self.read_nil(_)
+      nil
+    end
+
+    def self.write_nil(io)
+      io.write("\x01".b)
+    end
+
     class << self
-      private :read_ord
+      private :read_data_type, :read_nil, :read_bool, :read_double,
+              :read_integer, :read_str, :read_array, :read_hash, :write_nil,
+              :write_bool, :write_double, :write_integer, :write_str,
+              :write_array, :write_hash
     end
   end
 end

data/lib/rbstarbound/sbvj01.rb

@@ -1,42 +1,50 @@
 # frozen_string_literal: true
 
+require 'rbstarbound/player'
+
 module RBStarbound
   module SBVJ01
-    Player = Struct.new(:name, :version, :data) do
-      def player_name
-        data['identity']['name']
-      end
-
-      def uuid
-        data['identity']['uuid']
-      end
-    end
-
     def self.parse(io)
       unless sbvj01_header?(io)
         raise RBStarbound::SBVJ01Error, 'Not a SBVJ01 file'
       end
-      get_player_data(io)
+      read_player_data(io)
     end
 
-    def self.write(io)
-      raise RBStarbound::NotImplementedError
+    def self.dump(io, player_data)
+      sbvj01_header(io)
+      write_player_data(io, player_data)
     end
 
-    def self.get_player_data(io)
+    def self.read_player_data(io)
       name = RBStarbound::SBON.read_string(io)
-      version = 'None'
-      version = io.read(4).unpack('i>') if io.readchar.ord != 0
+      version = nil
+      version = io.read(4).unpack('i>').first unless io.readchar.ord.zero?
       data = RBStarbound::SBON.read_dynamic(io)
-      Player.new(name, version, data)
+      RBStarbound::Player::Data.new(name, version, data)
+    end
+
+    def self.write_player_data(io, player_data)
+      RBStarbound::SBON.write_string(io, player_data.name)
+      if player_data.version.nil?
+        io.write([0].pack('c'))
+      else
+        io.write([1, player_data.version].pack('ci>'))
+      end
+      RBStarbound::SBON.write_dynamic(io, player_data.data)
     end
 
     def self.sbvj01_header?(io)
       io.read(6) == 'SBVJ01'
     end
 
+    def self.sbvj01_header(io)
+      io.write('SBVJ01')
+    end
+
     class << self
-      private :write, :get_player_data, :sbvj01_header?
+      private :sbvj01_header?, :sbvj01_header, :read_player_data,
+              :write_player_data
     end
   end
 end

data/lib/rbstarbound/utils.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module RBStarbound
+  def self.print_error(error)
+    puts 'An error occured: ' + error.message.split(' @ ').first
+  end
+end

data/lib/rbstarbound/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RBStarbound
-  VERSION = '0.1.0'
+  VERSION = '0.2.0'
 end

data/lib/rbstarbound.rb

@@ -1,21 +1,35 @@
+# frozen_string_literal: true
+
 require 'rbstarbound/version'
 require 'rbstarbound/exceptions'
+require 'rbstarbound/utils'
 require 'rbstarbound/sbvj01'
 require 'rbstarbound/sbon'
+require 'rbstarbound/exit_codes'
+require 'rbstarbound/main_command'
 
 module RBStarbound
-  def self.ping
-    puts 'Pong!'
-  end
-
   def self.parse_player_save_file(path)
     save_file = File.open(path, 'rb')
     parsed_data = SBVJ01.parse(save_file)
   rescue StandardError => e
-    puts 'An error occured: ' + e.message.split(' @ ').first
+    print_error(e)
+    return nil
   else
     return parsed_data
   ensure
     save_file.close unless save_file.nil?
   end
+
+  def self.dump_player_save_file(path, player_data)
+    save_file = File.open(path, 'w')
+    SBVJ01.dump(save_file, player_data)
+  rescue StandardError => e
+    print_error(e)
+    return false
+  else
+    return true
+  ensure
+    save_file.close unless save_file.nil?
+  end
 end

data/test/commands/dump_test.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require File.join(File.dirname(__FILE__), '../test_helper')
+
+class DumpCommandTest < Minitest::Test
+  def test_it_dumps_to_yaml
+    cmd = RBStarbound::MainCommand.new('', {})
+    file = Tempfile.new('dump_cmd_test_temp')
+    params = %w[dump -f yaml -i] << SAVE_FILE_PATH << '-o' << file.path
+    begin
+      cmd.run(params)
+      data = file.gets(DATA_COUNT)
+      refute_empty(data)
+    ensure
+      file.close
+      file.unlink
+    end
+  end
+end

data/test/commands/serialize_test.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require File.join(File.dirname(__FILE__), '../test_helper')
+
+class SerializeCommandTest < Minitest::Test
+  def test_it_serializes_from_yaml
+    cmd = RBStarbound::MainCommand.new('', {})
+    file = Tempfile.new('serialize_cmd_test_temp')
+    params = %w[serialize -f yaml -i] << YAML_FILE_PATH << '-o' << file.path
+    begin
+      cmd.run(params)
+      data = file.gets(DATA_COUNT)
+      refute_empty(data)
+    ensure
+      file.close
+      file.unlink
+    end
+  end
+end