steam_codec 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: eee4dc9e00766d0a54f476547502bcb1f3dcba75
-  data.tar.gz: 77f03fedd878d4b1b7a221d327bc56dd2b9e4076
+  metadata.gz: 93fd1b633432abfc06e6bb11aec0df481b4e366e
+  data.tar.gz: 89a9ca4cb5975b3abcbf0c6e818f61cf333bdbfe
 SHA512:
-  metadata.gz: d53efad14a7f667a56139fa2129b998b33cef15edfe600c6a52b219ef5952490c4250033a95f5f59927fd44c0434a5f45648e6039b136b3d5fa41414bed99e3d
-  data.tar.gz: 63589876c263ac878e4a1b1c8ece6193e39e14bfb675ec1181461af9bcef5ad585e2ef8cf785dcf291d3b83da953dc23b459ce32aab7d773823d3fa2a70c30fb
+  metadata.gz: b28226526d56a91911f058ed1be3a397825851cf41cef6700f212891dd2fa033896d6c8a52eeb84d910dcfff83a62995e345317528ca7b7e5edfb4e295c5cbb3
+  data.tar.gz: fb81d45dc2484c102e704024fad68014aed5115ada853d8fb9da4c632657c9e82431e0ff87db9c3d59bb615e2c3a2c9d4347fbf10623e25dff5992851d1230ce

data/Gemfile

@@ -1,3 +1,4 @@
+# encoding: UTF-8
 source 'https://rubygems.org'
 
 group :development, :test do

data/README.md

@@ -62,6 +62,7 @@ code coverage will also be generated
 [![Build Status](https://travis-ci.org/davispuh/SteamCodec.png?branch=master)](https://travis-ci.org/davispuh/SteamCodec)
 [![Dependency Status](https://gemnasium.com/davispuh/SteamCodec.png)](https://gemnasium.com/davispuh/SteamCodec)
 [![Coverage Status](https://coveralls.io/repos/davispuh/SteamCodec/badge.png)](https://coveralls.io/r/davispuh/SteamCodec)
+[![Code Climate](https://codeclimate.com/github/davispuh/SteamCodec.png)](https://codeclimate.com/github/davispuh/SteamCodec)
 
 ## Unlicense
 

data/Rakefile

@@ -1,3 +1,4 @@
+# encoding: UTF-8
 require "bundler/gem_tasks"
 require 'rspec/core/rake_task'
 require 'yard'

data/lib/steam_codec.rb

@@ -1,3 +1,4 @@
+# encoding: UTF-8
 require "steam_codec/version"
 require "steam_codec/key_values"
 require "steam_codec/value_array"

data/lib/steam_codec/acf.rb

@@ -1,3 +1,4 @@
+# encoding: UTF-8
 module SteamCodec
     class ACF
 
@@ -82,7 +83,7 @@ module SteamCodec
                 @UserConfig = userConfig
                 @Name = @UserConfig.name if @UserConfig.key?(:name)
                 @GameID = @UserConfig.gameid.to_i if @UserConfig.key?(:gameid)
-                @Installed = !@UserConfig.installdir.to_i.zero? if @UserConfig.key?(:installdir)
+                @Installed = !@UserConfig.installed.to_i.zero? if @UserConfig.key?(:installed)
                 @AppInstallDir = @UserConfig.appinstalldir if @UserConfig.key?(:appinstalldir)
                 @Language = @UserConfig.language if @UserConfig.key?(:language)
                 @BetaKey = @UserConfig.BetaKey if @UserConfig.key?(:BetaKey)

data/lib/steam_codec/key_values.rb

@@ -1,3 +1,4 @@
+# encoding: UTF-8
 require 'json'
 require 'insensitive_hash/minimal'
 
@@ -103,6 +104,31 @@ module SteamCodec
             self.loadFromJSON(json)
         end
 
+        def get(path = '')
+            fields = path.gsub(/^\/|\/$/, '').split('/')
+            current = self
+            fields.each do |name|
+                return nil if not current.key?(name)
+                current = current[name]
+            end
+            current
+        end
+
+        def asArray(name, seperator = '_')
+            data = []
+            counter = 0
+            cname = name+seperator+counter.to_s
+            data << self[cname] if key?(cname)
+            counter += 1
+            cname = name+seperator+counter.to_s
+            while key?(cname) do
+                data << self[cname]
+                counter += 1
+                cname = name+seperator+counter.to_s
+            end
+            data
+        end
+
         def method_missing(name, *args, &block) # :nodoc:
             return self[name] if args.empty? and block.nil? and key?(name)
             super

data/lib/steam_codec/value_array.rb

@@ -1,3 +1,4 @@
+# encoding: UTF-8
 module SteamCodec
     class ValueArray
         def initialize(valueHash = {})

data/lib/steam_codec/vdf.rb

@@ -1,3 +1,4 @@
+# encoding: UTF-8
 module SteamCodec
     class VDF < KeyValues
         # About VDF => http://wiki.teamfortress.com/wiki/WebAPI/VDF

data/lib/steam_codec/version.rb

@@ -1,3 +1,4 @@
+# encoding: UTF-8
 module SteamCodec
-  VERSION = "0.0.2"
+    VERSION = '0.0.3'
 end

data/spec/acf_spec.rb

@@ -1,137 +1,138 @@
-require 'spec_helper'
-
-describe SteamCodec::ACF do
-
-    let(:appCacheFile) { <<-EOS
-        "AppState"
-        {
-            "appid"             "207930"
-            "Universe"          "1"
-            "StateFlags"        "4"
-            "installdir"        "sacred_citadel"
-            "LastUpdated"       "1377100000"
-            "UpdateResult"      "0"
-            "SizeOnDisk"        "1193761500"
-            "buildid"           "60250"
-            "LastOwner"         "0"
-            "BytesToDownload"   "0"
-            "BytesDownloaded"   "0"
-            "FullValidateOnNextUpdate"    "1"
-            "UserConfig"
-            {
-                "name"          "Sacred Citadel"
-                "gameid"        "207930"
-                "installed"     "1"
-                "appinstalldir" "C:\\Steam\\steamapps\\common\\sacred_citadel"
-                "language"      "english"
-                "BetaKey"       "public"
-            }
-            "MountedDepots"
-            {
-                "228982"        "6039653574073929574"
-                "228983"        "4721092052804263356"
-            }
-            "SharedDepots"
-            {
-                "228984"        "228980"
-            }
-            "checkguid"
-            {
-                "0"     "Bin\\some.exe"
-                "1"     "Bin\\another.exe"
-            }
-            "InstallScripts"
-            {
-                "0"     "_CommonRedist\\vcredist\\2008\\installscript.vdf"
-                "1"     "_CommonRedist\\vcredist\\2010\\installscript.vdf"
-            }
-        }
-        EOS
-    }
-
-    describe '.loadFromFile' do
-        it 'should successfully load from file' do
-            StringIO.open(appCacheFile) do |file|
-                SteamCodec::ACF::loadFromFile(file).should be_an_instance_of SteamCodec::ACF
-            end
-        end
-    end
-
-    describe '.load' do
-        it 'should successfully load' do
-            SteamCodec::ACF::load(appCacheFile).should be_an_instance_of SteamCodec::ACF
-        end
-    end
-
-    describe '.new' do
-        it 'should initialize new instance with empty fields' do
-            SteamCodec::ACF.new.AppID.should be_nil
-        end
-    end
-
-    describe '#InstallDir' do
-        it 'should return value' do
-            SteamCodec::ACF::load(appCacheFile).InstallDir.should eq("sacred_citadel")
-        end
-    end
-
-    describe SteamCodec::ACF::UserConfig do
-        describe '.new' do
-            it 'should initialize new instance with empty fields' do
-                SteamCodec::ACF::UserConfig.new.Name.should be_nil
-            end
-
-            it 'should initialize new instance with provided fields' do
-                SteamCodec::ACF::UserConfig.new(SteamCodec::KeyValues[{"Name" => "Game"}]).Name.should eq("Game")
-            end
-        end
-    end
-
-    describe SteamCodec::ACF::MountedDepots do
-        let(:depots) { {"228982" => "6039653574073929574"} }
-        describe '.new' do
-            it 'should initialize new instance with empty fields' do
-                SteamCodec::ACF::MountedDepots.new.depots.should eq([])
-                SteamCodec::ACF::MountedDepots.new.manifests.should eq([])
-            end
-
-            it 'should initialize new instance with provided fields' do
-                SteamCodec::ACF::MountedDepots.new(depots).depots.should eq([228982])
-                SteamCodec::ACF::MountedDepots.new(depots).manifests.should eq(["6039653574073929574"])
-            end
-        end
-
-        describe '#getManifest' do
-            it 'should return manifest' do
-                SteamCodec::ACF::MountedDepots.new(depots).getManifest(228982).should eq("6039653574073929574")
-            end
-        end
-
-        describe '#getDepot' do
-            it 'should return depot' do
-                SteamCodec::ACF::MountedDepots.new(depots).getDepot("6039653574073929574").should eq(228982)
-            end
-        end
-    end
-
-    describe SteamCodec::ACF::SharedDepots do
-        let(:depots) { {"228984" => "228980"} }
-        describe '.new' do
-            it 'should initialize new instance with empty fields' do
-                SteamCodec::ACF::SharedDepots.new.depots.should eq([])
-            end
-
-            it 'should initialize new instance with provided fields' do
-                SteamCodec::ACF::SharedDepots.new(depots).depots.should eq([228984])
-                SteamCodec::ACF::SharedDepots.new(depots).getDepot(228984).should eq(228980)
-            end
-        end
-
-        describe '#getDepot' do
-            it 'should return depot' do
-                SteamCodec::ACF::SharedDepots.new(depots).getDepot(228984).should eq(228980)
-            end
-        end
-    end
-
-end
+# encoding: UTF-8
+require 'spec_helper'
+
+describe SteamCodec::ACF do
+
+    let(:appCacheFile) { <<-EOS
+        "AppState"
+        {
+            "appid"             "207930"
+            "Universe"          "1"
+            "StateFlags"        "4"
+            "installdir"        "sacred_citadel"
+            "LastUpdated"       "1377100000"
+            "UpdateResult"      "0"
+            "SizeOnDisk"        "1193761500"
+            "buildid"           "60250"
+            "LastOwner"         "0"
+            "BytesToDownload"   "0"
+            "BytesDownloaded"   "0"
+            "FullValidateOnNextUpdate"    "1"
+            "UserConfig"
+            {
+                "name"          "Sacred Citadel"
+                "gameid"        "207930"
+                "installed"     "1"
+                "appinstalldir" "C:\\Steam\\steamapps\\common\\sacred_citadel"
+                "language"      "english"
+                "BetaKey"       "public"
+            }
+            "MountedDepots"
+            {
+                "228982"        "6039653574073929574"
+                "228983"        "4721092052804263356"
+            }
+            "SharedDepots"
+            {
+                "228984"        "228980"
+            }
+            "checkguid"
+            {
+                "0"     "Bin\\some.exe"
+                "1"     "Bin\\another.exe"
+            }
+            "InstallScripts"
+            {
+                "0"     "_CommonRedist\\vcredist\\2008\\installscript.vdf"
+                "1"     "_CommonRedist\\vcredist\\2010\\installscript.vdf"
+            }
+        }
+        EOS
+    }
+
+    describe '.loadFromFile' do
+        it 'should successfully load from file' do
+            StringIO.open(appCacheFile) do |file|
+                SteamCodec::ACF::loadFromFile(file).should be_an_instance_of SteamCodec::ACF
+            end
+        end
+    end
+
+    describe '.load' do
+        it 'should successfully load' do
+            SteamCodec::ACF::load(appCacheFile).should be_an_instance_of SteamCodec::ACF
+        end
+    end
+
+    describe '.new' do
+        it 'should initialize new instance with empty fields' do
+            SteamCodec::ACF.new.AppID.should be_nil
+        end
+    end
+
+    describe '#InstallDir' do
+        it 'should return value' do
+            SteamCodec::ACF::load(appCacheFile).InstallDir.should eq("sacred_citadel")
+        end
+    end
+
+    describe SteamCodec::ACF::UserConfig do
+        describe '.new' do
+            it 'should initialize new instance with empty fields' do
+                SteamCodec::ACF::UserConfig.new.Name.should be_nil
+            end
+
+            it 'should initialize new instance with provided fields' do
+                SteamCodec::ACF::UserConfig.new(SteamCodec::KeyValues[{"Name" => "Game"}]).Name.should eq("Game")
+            end
+        end
+    end
+
+    describe SteamCodec::ACF::MountedDepots do
+        let(:depots) { {"228982" => "6039653574073929574"} }
+        describe '.new' do
+            it 'should initialize new instance with empty fields' do
+                SteamCodec::ACF::MountedDepots.new.depots.should eq([])
+                SteamCodec::ACF::MountedDepots.new.manifests.should eq([])
+            end
+
+            it 'should initialize new instance with provided fields' do
+                SteamCodec::ACF::MountedDepots.new(depots).depots.should eq([228982])
+                SteamCodec::ACF::MountedDepots.new(depots).manifests.should eq(["6039653574073929574"])
+            end
+        end
+
+        describe '#getManifest' do
+            it 'should return manifest' do
+                SteamCodec::ACF::MountedDepots.new(depots).getManifest(228982).should eq("6039653574073929574")
+            end
+        end
+
+        describe '#getDepot' do
+            it 'should return depot' do
+                SteamCodec::ACF::MountedDepots.new(depots).getDepot("6039653574073929574").should eq(228982)
+            end
+        end
+    end
+
+    describe SteamCodec::ACF::SharedDepots do
+        let(:depots) { {"228984" => "228980"} }
+        describe '.new' do
+            it 'should initialize new instance with empty fields' do
+                SteamCodec::ACF::SharedDepots.new.depots.should eq([])
+            end
+
+            it 'should initialize new instance with provided fields' do
+                SteamCodec::ACF::SharedDepots.new(depots).depots.should eq([228984])
+                SteamCodec::ACF::SharedDepots.new(depots).getDepot(228984).should eq(228980)
+            end
+        end
+
+        describe '#getDepot' do
+            it 'should return depot' do
+                SteamCodec::ACF::SharedDepots.new(depots).getDepot(228984).should eq(228980)
+            end
+        end
+    end
+
+end

data/spec/key_values_spec.rb

@@ -1,179 +1,216 @@
-require 'spec_helper'
-
-describe SteamCodec::KeyValues do
-
-    let(:tokenKey) { 'TokenKey123' }
-    let(:tokenValue) { 'Token+Value4567' }
-    let(:tokenKeyQuoted) { "\"#{tokenKey}\"" }
-    let(:tokenValueQuoted) { "\"#{tokenValue}\"" }
-
-    let(:jsonSample1a) { "#{tokenKeyQuoted} #{tokenValueQuoted}" }
-    let(:jsonSample1b) { "#{tokenKeyQuoted}\n{\t#{tokenKeyQuoted}\t#{tokenValueQuoted}\n}" }
-
-    let(:jsonSample2a) { "#{tokenKeyQuoted} #{tokenValueQuoted}\n#{tokenKeyQuoted}\t#{tokenValueQuoted}" }
-    let(:jsonSample2b) { "#{tokenKeyQuoted}\t{}\n#{tokenKeyQuoted} #{tokenValueQuoted}" }
-
-    let(:jsonSample3a) { '"Ke\\ty\\\\is" "Val\\nue\\\\\\""' }
-    let(:jsonSample3b) { '"Ke\\\\ty\\is\\\\" "te\\\\s\\\\n\\\\v\\"\\\\"' }
-
-    let(:jsonSample4a) { "#{tokenKey} #{tokenValue}" }
-    let(:jsonSample4b) { "#{tokenKey}\n{\t#{tokenKey}\t#{tokenValue}\n}" }
-
-    let(:jsonSample5a) { 'abc "lol this {weird string}"' }
-    let(:jsonSample5b) { "\"\\\"really weird\\\"\n{\n\\\"string\\\" \\\"this is\\\"\n}\"\n{\n\"string\" \"this is\"\n}" }
-
-    let(:jsonSample6a) { "#{tokenKeyQuoted}\\\\this should be ignored\n{\t#{tokenKeyQuoted}\t#{tokenValueQuoted}\n}" }
-
-    let(:jsonSample7a) { "#base <blah.vdf>\n#{tokenKey}\n{\t#{tokenKey}\t#{tokenValue}\n}" }
-    let(:jsonSample7b) { "#include <blah.vdf>\n#{tokenKey}\n{\t#{tokenKey}\t#{tokenValue}\n}" }
-
-    let(:keyValueData) { <<-EOS
-        "AppState"
-        {
-            "appid"     "320"
-            "Universe"  "1"
-        }
-        EOS
-    }
-
-    describe SteamCodec::KeyValues::Parser do
-
-        describe '.isEscaped' do
-            it 'empty string should not be escaped' do
-                SteamCodec::KeyValues::Parser::isEscaped('', 0).should be_false
-            end
-
-            it 'should be escaped' do
-                SteamCodec::KeyValues::Parser::isEscaped('\\"', 1).should be_true
-                SteamCodec::KeyValues::Parser::isEscaped('\\\\\\"', 3).should be_true
-                SteamCodec::KeyValues::Parser::isEscaped('trol\\lol\\lol\\"trrr', 13).should be_true
-            end
-
-            it 'should not be escaped' do
-                SteamCodec::KeyValues::Parser::isEscaped('\\\\"', 2).should be_false
-                SteamCodec::KeyValues::Parser::isEscaped('\\\\\\\\"', 4).should be_false
-                SteamCodec::KeyValues::Parser::isEscaped('trol\\lol\\lol\\\\"trrr', 14).should be_false
-            end
-
-        end
-
-        describe '.toJSON' do
-            it 'should convert correctly empty data' do
-                SteamCodec::KeyValues::Parser::toJSON('').should eq('{}')
-            end
-
-            it 'should raise exception on invalid data' do
-                expect { SteamCodec::KeyValues::Parser::toJSON(nil) }.to raise_error(ArgumentError)
-                expect { SteamCodec::KeyValues::Parser::toJSON({})  }.to raise_error(ArgumentError)
-            end
-
-            it 'should add colon after tokens' do
-                SteamCodec::KeyValues::Parser::toJSON(jsonSample1a).should eq("{#{tokenKeyQuoted}: #{tokenValueQuoted}}")
-                SteamCodec::KeyValues::Parser::toJSON(jsonSample1b).should eq("{#{tokenKeyQuoted}:\n{\t#{tokenKeyQuoted}:\t#{tokenValueQuoted}\n}}")
-            end
-
-            it 'should add comma after entries' do
-                SteamCodec::KeyValues::Parser::toJSON(jsonSample2a).should eq("{#{tokenKeyQuoted}: #{tokenValueQuoted},\n#{tokenKeyQuoted}:\t#{tokenValueQuoted}}")
-                SteamCodec::KeyValues::Parser::toJSON(jsonSample2b).should eq("{#{tokenKeyQuoted}:\t{},\n#{tokenKeyQuoted}: #{tokenValueQuoted}}")
-            end
-
-            it 'should regard slashes' do
-                SteamCodec::KeyValues::Parser::toJSON(jsonSample3a).should eq('{"Ke\\ty\\\\is": "Val\\nue\\\\\\""}')
-                SteamCodec::KeyValues::Parser::toJSON(jsonSample3b).should eq('{"Ke\\\\ty\\is\\\\": "te\\\\s\\\\n\\\\v\\"\\\\"}')
-            end
-
-            it 'should parse keys and values without quotes' do
-                SteamCodec::KeyValues::Parser::toJSON(jsonSample4a).should eq("{#{tokenKeyQuoted}: #{tokenValueQuoted}}")
-                SteamCodec::KeyValues::Parser::toJSON(jsonSample4b).should eq("{#{tokenKeyQuoted}:\n{\t#{tokenKeyQuoted}:\t#{tokenValueQuoted}\n}}")
-            end
-
-            it 'should parse special cases' do
-                SteamCodec::KeyValues::Parser::toJSON(jsonSample5a).should eq("{\"abc\": \"lol this {weird string}\"}")
-                SteamCodec::KeyValues::Parser::toJSON(jsonSample5b).should eq("{\"\\\"really weird\\\"\\n{\\n\\\"string\\\" \\\"this is\\\"\\n}\":\n{\n\"string\": \"this is\"\n}}")
-            end
-
-            it 'should ignore comments' do
-                SteamCodec::KeyValues::Parser::toJSON(jsonSample6a).should eq("{#{tokenKeyQuoted}:\n{\t#{tokenKeyQuoted}:\t#{tokenValueQuoted}\n}}")
-            end
-
-            it 'should ignore #include and #base' do
-                SteamCodec::KeyValues::Parser::toJSON(jsonSample7a).should eq("{\n#{tokenKeyQuoted}:\n{\t#{tokenKeyQuoted}:\t#{tokenValueQuoted}\n}}")
-                SteamCodec::KeyValues::Parser::toJSON(jsonSample7b).should eq("{\n#{tokenKeyQuoted}:\n{\t#{tokenKeyQuoted}:\t#{tokenValueQuoted}\n}}")
+# encoding: UTF-8
+require 'spec_helper'
+
+describe SteamCodec::KeyValues do
+
+    let(:tokenKey) { 'ToknKey123' }
+    let(:tokenValue) { 'Tokén+Value4567' }
+    let(:tokenKeyQuoted) { "\"#{tokenKey}\"" }
+    let(:tokenValueQuoted) { "\"#{tokenValue}\"" }
+
+    let(:jsonSample1a) { "#{tokenKeyQuoted} #{tokenValueQuoted}" }
+    let(:jsonSample1b) { "#{tokenKeyQuoted}\n{\t#{tokenKeyQuoted}\t#{tokenValueQuoted}\n}" }
+
+    let(:jsonSample2a) { "#{tokenKeyQuoted} #{tokenValueQuoted}\n#{tokenKeyQuoted}\t#{tokenValueQuoted}" }
+    let(:jsonSample2b) { "#{tokenKeyQuoted}\t{}\n#{tokenKeyQuoted} #{tokenValueQuoted}" }
+
+    let(:jsonSample3a) { '"Ke\\ty\\\\is" "Val\\nue\\\\\\""' }
+    let(:jsonSample3b) { '"Ke\\\\ty\\is\\\\" "te\\\\s\\\\n\\\\v\\"\\\\"' }
+
+    let(:jsonSample4a) { "#{tokenKey} #{tokenValue}" }
+    let(:jsonSample4b) { "#{tokenKey}\n{\t#{tokenKey}\t#{tokenValue}\n}" }
+
+    let(:jsonSample5a) { 'abc "lol this {weird string}"' }
+    let(:jsonSample5b) { "\"\\\"really weird\\\"\n{\n\\\"string\\\" \\\"this is\\\"\n}\"\n{\n\"string\" \"this is\"\n}" }
+
+    let(:jsonSample6a) { "#{tokenKeyQuoted}\\\\this should be ignored\n{\t#{tokenKeyQuoted}\t#{tokenValueQuoted}\n}" }
+
+    let(:jsonSample7a) { "#base <blah.vdf>\n#{tokenKey}\n{\t#{tokenKey}\t#{tokenValue}\n}" }
+    let(:jsonSample7b) { "#include <blah.vdf>\n#{tokenKey}\n{\t#{tokenKey}\t#{tokenValue}\n}" }
+
+    let(:keyValueData) { <<-EOS
+        "AppState"
+        {
+            "appid"     "320"
+            "Universe"  "1"
+            "SomeArrayValue_1"  "4"
+            "SomeArrayValue_2"  "3"
+            "SomeArrayValue_3"  "2"
+            "UserConfig"
+             {
+                 "name"     "Brütal Legend"
+             }
+        }
+        EOS
+    }
+
+    let(:keyValueResult) {
+        { 'appid' => '320', 'Universe' => '1', 'SomeArrayValue_1' => '4', 'SomeArrayValue_2' => '3', 'SomeArrayValue_3' => '2', 'UserConfig' => {'name' => 'Brütal Legend'} }
+    }
+
+    describe SteamCodec::KeyValues::Parser do
+
+        describe '.isEscaped' do
+            it 'empty string should not be escaped' do
+                SteamCodec::KeyValues::Parser::isEscaped('', 0).should be_false
             end
-        end
-    end
-
-    describe '.loadFromJSON' do
-        it 'should return nil for invalid json' do
-            SteamCodec::KeyValues::loadFromJSON('invalid :P').should be_nil
-        end
-    end
-
-    describe '.load' do
-        it 'should load correctly empty data' do
-            SteamCodec::KeyValues::load('').should eq({})
-        end
-
-        it 'should raise exception on invalid data' do
-            expect { SteamCodec::KeyValues::load(nil) }.to raise_error(ArgumentError)
-            expect { SteamCodec::KeyValues::load({})  }.to raise_error(ArgumentError)
-        end
-
-        it 'should load correctly various representations' do
-            SteamCodec::KeyValues::load(jsonSample1a).should eq({ tokenKey => tokenValue })
-            SteamCodec::KeyValues::load(jsonSample1b).should eq({ tokenKey => { tokenKey => tokenValue } })
-            SteamCodec::KeyValues::load(jsonSample2a).should eq({ tokenKey => tokenValue })
-            SteamCodec::KeyValues::load(jsonSample2b).should eq({ tokenKey => tokenValue })
-            SteamCodec::KeyValues::load(jsonSample3a).should eq({"Ke\ty\\is" => "Val\nue\\\""})
-            SteamCodec::KeyValues::load(jsonSample3b).should eq({'Ke\\tyis\\' => "te\\s\\n\\v\"\\"})
-            SteamCodec::KeyValues::load(jsonSample4a).should eq({ tokenKey => tokenValue })
-            SteamCodec::KeyValues::load(jsonSample4b).should eq({ tokenKey => { tokenKey => tokenValue } })
-            SteamCodec::KeyValues::load(jsonSample5a).should eq({"abc" => "lol this {weird string}"})
-            SteamCodec::KeyValues::load(jsonSample5b).should eq({"\"really weird\"\n{\n\"string\" \"this is\"\n}" => {"string" => "this is"}})
-            SteamCodec::KeyValues::load(jsonSample6a).should eq({ tokenKey => { tokenKey => tokenValue } })
-            SteamCodec::KeyValues::load(jsonSample7a).should eq({ tokenKey => { tokenKey => tokenValue } })
-            SteamCodec::KeyValues::load(jsonSample7b).should eq({ tokenKey => { tokenKey => tokenValue } })
-        end
-    end
-
-    describe '.loadFromFile' do
-        it 'should raise exception if not file' do
-            expect { SteamCodec::KeyValues::loadFromFile("blah") }.to raise_error(ArgumentError)
-        end
-
-        it 'should succesfully load from file' do
-            StringIO.open(keyValueData) do |file|
-                SteamCodec::KeyValues::loadFromFile(file).should eq({ "AppState" => { "appid" => "320", "Universe" => "1" } })
-            end
-        end
-
-        it 'should be KeyValues instance' do
-            StringIO.open(keyValueData) do |file|
-                SteamCodec::KeyValues::loadFromFile(file).should be_an_instance_of SteamCodec::KeyValues
-            end
-        end
-    end
-
-    describe 'access any field' do
-        let(:keyValues) { SteamCodec::KeyValues::load(keyValueData) }
-        it 'should be able to access AppState' do
-            keyValues.AppState.should eq({ "appid" => "320", "Universe" => "1" })
-        end
-
-        it 'should be able to read AppID' do
-            keyValues.AppState.AppID.should eq("320")
-        end
-
-        it 'should check if field exists' do
-            keyValues.AppState.has_key?(:AppID).should be_true
-            keyValues.AppState.has_key?(:UserConfig).should be_false
-            keyValues.respond_to?(:appstate).should be_true
-            keyValues.respond_to?(:nope).should be_false
-        end
-
-        it 'should raise exception for non-existent field' do
-            expect { keyValues.AppState.UserConfig }.to raise_error(NoMethodError)
-        end
-    end
-
-end
+
+            it 'should be escaped' do
+                SteamCodec::KeyValues::Parser::isEscaped('\\"', 1).should be_true
+                SteamCodec::KeyValues::Parser::isEscaped('\\\\\\"', 3).should be_true
+                SteamCodec::KeyValues::Parser::isEscaped('trol\\lol\\lol\\"trrr', 13).should be_true
+            end
+
+            it 'should not be escaped' do
+                SteamCodec::KeyValues::Parser::isEscaped('\\\\"', 2).should be_false
+                SteamCodec::KeyValues::Parser::isEscaped('\\\\\\\\"', 4).should be_false
+                SteamCodec::KeyValues::Parser::isEscaped('trol\\lol\\lol\\\\"trrr', 14).should be_false
+            end
+
+        end
+
+        describe '.toJSON' do
+            it 'should convert correctly empty data' do
+                SteamCodec::KeyValues::Parser::toJSON('').should eq('{}')
+            end
+
+            it 'should raise exception on invalid data' do
+                expect { SteamCodec::KeyValues::Parser::toJSON(nil) }.to raise_error(ArgumentError)
+                expect { SteamCodec::KeyValues::Parser::toJSON({})  }.to raise_error(ArgumentError)
+            end
+
+            it 'should add colon after tokens' do
+                SteamCodec::KeyValues::Parser::toJSON(jsonSample1a).should eq("{#{tokenKeyQuoted}: #{tokenValueQuoted}}")
+                SteamCodec::KeyValues::Parser::toJSON(jsonSample1b).should eq("{#{tokenKeyQuoted}:\n{\t#{tokenKeyQuoted}:\t#{tokenValueQuoted}\n}}")
+            end
+
+            it 'should add comma after entries' do
+                SteamCodec::KeyValues::Parser::toJSON(jsonSample2a).should eq("{#{tokenKeyQuoted}: #{tokenValueQuoted},\n#{tokenKeyQuoted}:\t#{tokenValueQuoted}}")
+                SteamCodec::KeyValues::Parser::toJSON(jsonSample2b).should eq("{#{tokenKeyQuoted}:\t{},\n#{tokenKeyQuoted}: #{tokenValueQuoted}}")
+            end
+
+            it 'should regard slashes' do
+                SteamCodec::KeyValues::Parser::toJSON(jsonSample3a).should eq('{"Ke\\ty\\\\is": "Val\\nue\\\\\\""}')
+                SteamCodec::KeyValues::Parser::toJSON(jsonSample3b).should eq('{"Ke\\\\ty\\is\\\\": "te\\\\s\\\\n\\\\v\\"\\\\"}')
+            end
+
+            it 'should parse keys and values without quotes' do
+                SteamCodec::KeyValues::Parser::toJSON(jsonSample4a).should eq("{#{tokenKeyQuoted}: #{tokenValueQuoted}}")
+                SteamCodec::KeyValues::Parser::toJSON(jsonSample4b).should eq("{#{tokenKeyQuoted}:\n{\t#{tokenKeyQuoted}:\t#{tokenValueQuoted}\n}}")
+            end
+
+            it 'should parse special cases' do
+                SteamCodec::KeyValues::Parser::toJSON(jsonSample5a).should eq("{\"abc\": \"lol this {weird string}\"}")
+                SteamCodec::KeyValues::Parser::toJSON(jsonSample5b).should eq("{\"\\\"really weird\\\"\\n{\\n\\\"string\\\" \\\"this is\\\"\\n}\":\n{\n\"string\": \"this is\"\n}}")
+            end
+
+            it 'should ignore comments' do
+                SteamCodec::KeyValues::Parser::toJSON(jsonSample6a).should eq("{#{tokenKeyQuoted}:\n{\t#{tokenKeyQuoted}:\t#{tokenValueQuoted}\n}}")
+            end
+
+            it 'should ignore #include and #base' do
+                SteamCodec::KeyValues::Parser::toJSON(jsonSample7a).should eq("{\n#{tokenKeyQuoted}:\n{\t#{tokenKeyQuoted}:\t#{tokenValueQuoted}\n}}")
+                SteamCodec::KeyValues::Parser::toJSON(jsonSample7b).should eq("{\n#{tokenKeyQuoted}:\n{\t#{tokenKeyQuoted}:\t#{tokenValueQuoted}\n}}")
+            end
+        end
+    end
+
+    describe '.loadFromJSON' do
+        it 'should return nil for invalid json' do
+            SteamCodec::KeyValues::loadFromJSON('invalid :P').should be_nil
+        end
+    end
+
+    describe '.load' do
+        it 'should load correctly empty data' do
+            SteamCodec::KeyValues::load('').should eq({})
+        end
+
+        it 'should raise exception on invalid data' do
+            expect { SteamCodec::KeyValues::load(nil) }.to raise_error(ArgumentError)
+            expect { SteamCodec::KeyValues::load({})  }.to raise_error(ArgumentError)
+        end
+
+        it 'should load correctly various representations' do
+            SteamCodec::KeyValues::load(jsonSample1a).should eq({ tokenKey => tokenValue })
+            SteamCodec::KeyValues::load(jsonSample1b).should eq({ tokenKey => { tokenKey => tokenValue } })
+            SteamCodec::KeyValues::load(jsonSample2a).should eq({ tokenKey => tokenValue })
+            SteamCodec::KeyValues::load(jsonSample2b).should eq({ tokenKey => tokenValue })
+            SteamCodec::KeyValues::load(jsonSample3a).should eq({"Ke\ty\\is" => "Val\nue\\\""})
+            SteamCodec::KeyValues::load(jsonSample3b).should eq({'Ke\\tyis\\' => "te\\s\\n\\v\"\\"})
+            SteamCodec::KeyValues::load(jsonSample4a).should eq({ tokenKey => tokenValue })
+            SteamCodec::KeyValues::load(jsonSample4b).should eq({ tokenKey => { tokenKey => tokenValue } })
+            SteamCodec::KeyValues::load(jsonSample5a).should eq({"abc" => "lol this {weird string}"})
+            SteamCodec::KeyValues::load(jsonSample5b).should eq({"\"really weird\"\n{\n\"string\" \"this is\"\n}" => {"string" => "this is"}})
+            SteamCodec::KeyValues::load(jsonSample6a).should eq({ tokenKey => { tokenKey => tokenValue } })
+            SteamCodec::KeyValues::load(jsonSample7a).should eq({ tokenKey => { tokenKey => tokenValue } })
+            SteamCodec::KeyValues::load(jsonSample7b).should eq({ tokenKey => { tokenKey => tokenValue } })
+        end
+    end
+
+    describe '.loadFromFile' do
+        it 'should raise exception if not file' do
+            expect { SteamCodec::KeyValues::loadFromFile("blah") }.to raise_error(ArgumentError)
+        end
+
+        it 'should succesfully load from file' do
+            StringIO.open(keyValueData) do |file|
+                SteamCodec::KeyValues::loadFromFile(file).should eq({ "AppState" => keyValueResult })
+            end
+        end
+
+        it 'should be KeyValues instance' do
+            StringIO.open(keyValueData) do |file|
+                SteamCodec::KeyValues::loadFromFile(file).should be_an_instance_of SteamCodec::KeyValues
+            end
+        end
+    end
+
+    describe '#get' do
+        let(:keyValues) { SteamCodec::KeyValues::load(keyValueData) }
+
+        it 'should get field value' do
+            keyValues.get('AppState/AppID').should eq("320")
+        end
+
+        it 'should get field value even with slashes at start and end' do
+            keyValues.get('/AppState/AppID/').should eq("320")
+        end
+
+        it 'should be nil if field doesn\'t exist' do
+            keyValues.get('AppState/Something').should be_nil
+        end
+    end
+
+    describe '#asArray' do
+        let(:keyValues) { SteamCodec::KeyValues::load(keyValueData) }
+
+        it 'should load fields as array' do
+            keyValues.AppState.asArray('SomeArrayValue').should eq(['4','3','2'])
+        end
+    end
+
+    describe 'access any field' do
+        let(:keyValues) { SteamCodec::KeyValues::load(keyValueData) }
+
+        it 'should be able to access AppState' do
+            keyValues.AppState.should eq(keyValueResult)
+        end
+
+        it 'should be able to read AppID' do
+            keyValues.AppState.AppID.should eq("320")
+        end
+
+        it 'should check if field exists' do
+            keyValues.AppState.has_key?(:AppID).should be_true
+            keyValues.AppState.has_key?(:StateFlags).should be_false
+            keyValues.respond_to?(:appstate).should be_true
+            keyValues.respond_to?(:nope).should be_false
+        end
+
+        it 'should raise exception for non-existent field' do
+            expect { keyValues.AppState.StateFlags }.to raise_error(NoMethodError)
+        end
+    end
+
+end

data/spec/spec_helper.rb

@@ -1,4 +1,5 @@
-require 'simplecov'
-
-SimpleCov.start
-require_relative '../lib/steam_codec'
+# encoding: UTF-8
+require 'simplecov'
+
+SimpleCov.start
+require_relative '../lib/steam_codec'

data/spec/vdf_spec.rb

@@ -1,136 +1,137 @@
-require 'spec_helper'
-
-describe SteamCodec::VDF do
-
-    let(:valveDataFile) { <<-EOS
-        "InstallScript"
-        {
-            "Registry"
-            {
-                "HKEY_LOCAL_MACHINE\\SOFTWARE\\Activision\\Singularity"
-                {
-                    "string"
-                    {
-                        "EXEString"     "%INSTALLDIR%\\Binaries\\Singularity.exe"
-                        "InstallPath"       "%INSTALLDIR%"
-                        "IntVersion"        "35.0"
-                        "Version"       "1.0"
-                        "english"
-                        {
-                            "Language"      "1033"
-                            "LanguageCode"      "ENU"
-                            "Localization"      "ENU"
-                        }
-                        "french"
-                        {
-                            "Language"      "1036"
-                            "LanguageCode"      "FRA"
-                            "Localization"      "FRA"
-                        }
-                        "german"
-                        {
-                            "Language"      "1031"
-                            "LanguageCode"      "DEU"
-                            "Localization"      "DEU"
-                        }
-                        "italian"
-                        {
-                            "Language"      "1040"
-                            "LanguageCode"      "ITA"
-                            "Localization"      "ITA"
-                        }
-                        "spanish"
-                        {
-                            "Language"      "1034"
-                            "LanguageCode"      "ESP"
-                            "Localization"      "ESP"
-                        }
-                    }
-                    "dword"
-                    {
-                        "english"
-                        {
-                            "GameLanguage"      "0"
-                        }
-                        "french"
-                        {
-                            "GameLanguage"      "1"
-                        }
-                        "german"
-                        {
-                            "GameLanguage"      "0"
-                        }
-                        "italian"
-                        {
-                            "GameLanguage"      "2"
-                        }
-                        "spanish"
-                        {
-                            "GameLanguage"      "4"
-                        }
-                    }
-                }
-            }
-            "Run Process"
-            {
-                "DirectX"
-                {
-                    "process 1"     "%INSTALLDIR%\\redist\\DirectX\\DXSETUP.exe"
-                    "command 1"     "/silent"
-                    "Description"       "DirectX Installation"
-                    "NoCleanUp"     "1"
-                }
-                "VC++"
-                {
-                    "process 1"     "%INSTALLDIR%\\redist\\vcredist_x86.exe"
-                    "command 1"     "/q:a"
-                    "process 2"     "%INSTALLDIR%\\redist\\vcredist_x86_2005.exe"
-                    "command 2"     "/q:a"
-                    "Description"       "VC++ Redist Installation"
-                    "NoCleanUp"     "1"
-                }
-                "PhysX Version"
-                {
-                    "HasRunKey"     "HKEY_LOCAL_MACHINE\\SOFTWARE\\AGEIA Technologies"
-                    "process 1"     "%INSTALLDIR%\\redist\\PhysX_9.09.1112_SystemSoftware.exe"
-                    "command 1"     "/quiet"
-                    "NoCleanUp"     "1"
-                    "MinimumHasRunValue"        "9091112"
-                }
-            }
-        }
-        "kvsignatures"
-        {
-            "InstallScript"     "973f7d89125ad1fc782a970deb175cf84d48c49581ba3a76fedfefa8116a6d500459fd8df99285850ef99d767a83c2de009de5951607930557c937439908fbc1cc8156e963320c54080e7a1a634ccbf2e5f58883bd11bb2ed10c07be5af8e482d9a17d22a6fe40980124e5fced1c241f158b460941984c41432eeeb2aeaa01b1"
-        }        
-        EOS
-    }
-
-    describe '.loadFromFile' do
-        it 'should successfully load from file' do
-            StringIO.open(valveDataFile) do |file|
-                SteamCodec::VDF::loadFromFile(file).should be_an_instance_of SteamCodec::VDF
-            end
-        end
-    end
-
-    describe '.load' do
-        it 'should successfully load' do
-            SteamCodec::VDF::load(valveDataFile).should be_an_instance_of SteamCodec::VDF
-        end
-    end
-
-    describe 'key field' do
-        it 'should return value' do
-            SteamCodec::VDF::load(valveDataFile).InstallScript.Registry.should be_an_instance_of SteamCodec::KeyValues
-        end
-    end
-
-    describe '#isSignaturesValid?' do
-        it 'should check if signature is valid' do
-            SteamCodec::VDF.new.isSignaturesValid?(nil).should be_true
-            SteamCodec::VDF::load(valveDataFile).isSignaturesValid?(nil).should be_false
-        end
-    end
-
-end
+# encoding: UTF-8
+require 'spec_helper'
+
+describe SteamCodec::VDF do
+
+    let(:valveDataFile) { <<-EOS
+        "InstallScript"
+        {
+            "Registry"
+            {
+                "HKEY_LOCAL_MACHINE\\SOFTWARE\\Activision\\Singularity"
+                {
+                    "string"
+                    {
+                        "EXEString"     "%INSTALLDIR%\\Binaries\\Singularity.exe"
+                        "InstallPath"       "%INSTALLDIR%"
+                        "IntVersion"        "35.0"
+                        "Version"       "1.0"
+                        "english"
+                        {
+                            "Language"      "1033"
+                            "LanguageCode"      "ENU"
+                            "Localization"      "ENU"
+                        }
+                        "french"
+                        {
+                            "Language"      "1036"
+                            "LanguageCode"      "FRA"
+                            "Localization"      "FRA"
+                        }
+                        "german"
+                        {
+                            "Language"      "1031"
+                            "LanguageCode"      "DEU"
+                            "Localization"      "DEU"
+                        }
+                        "italian"
+                        {
+                            "Language"      "1040"
+                            "LanguageCode"      "ITA"
+                            "Localization"      "ITA"
+                        }
+                        "spanish"
+                        {
+                            "Language"      "1034"
+                            "LanguageCode"      "ESP"
+                            "Localization"      "ESP"
+                        }
+                    }
+                    "dword"
+                    {
+                        "english"
+                        {
+                            "GameLanguage"      "0"
+                        }
+                        "french"
+                        {
+                            "GameLanguage"      "1"
+                        }
+                        "german"
+                        {
+                            "GameLanguage"      "0"
+                        }
+                        "italian"
+                        {
+                            "GameLanguage"      "2"
+                        }
+                        "spanish"
+                        {
+                            "GameLanguage"      "4"
+                        }
+                    }
+                }
+            }
+            "Run Process"
+            {
+                "DirectX"
+                {
+                    "process 1"     "%INSTALLDIR%\\redist\\DirectX\\DXSETUP.exe"
+                    "command 1"     "/silent"
+                    "Description"       "DirectX Installation"
+                    "NoCleanUp"     "1"
+                }
+                "VC++"
+                {
+                    "process 1"     "%INSTALLDIR%\\redist\\vcredist_x86.exe"
+                    "command 1"     "/q:a"
+                    "process 2"     "%INSTALLDIR%\\redist\\vcredist_x86_2005.exe"
+                    "command 2"     "/q:a"
+                    "Description"       "VC++ Redist Installation"
+                    "NoCleanUp"     "1"
+                }
+                "PhysX Version"
+                {
+                    "HasRunKey"     "HKEY_LOCAL_MACHINE\\SOFTWARE\\AGEIA Technologies"
+                    "process 1"     "%INSTALLDIR%\\redist\\PhysX_9.09.1112_SystemSoftware.exe"
+                    "command 1"     "/quiet"
+                    "NoCleanUp"     "1"
+                    "MinimumHasRunValue"        "9091112"
+                }
+            }
+        }
+        "kvsignatures"
+        {
+            "InstallScript"     "973f7d89125ad1fc782a970deb175cf84d48c49581ba3a76fedfefa8116a6d500459fd8df99285850ef99d767a83c2de009de5951607930557c937439908fbc1cc8156e963320c54080e7a1a634ccbf2e5f58883bd11bb2ed10c07be5af8e482d9a17d22a6fe40980124e5fced1c241f158b460941984c41432eeeb2aeaa01b1"
+        }        
+        EOS
+    }
+
+    describe '.loadFromFile' do
+        it 'should successfully load from file' do
+            StringIO.open(valveDataFile) do |file|
+                SteamCodec::VDF::loadFromFile(file).should be_an_instance_of SteamCodec::VDF
+            end
+        end
+    end
+
+    describe '.load' do
+        it 'should successfully load' do
+            SteamCodec::VDF::load(valveDataFile).should be_an_instance_of SteamCodec::VDF
+        end
+    end
+
+    describe 'key field' do
+        it 'should return value' do
+            SteamCodec::VDF::load(valveDataFile).InstallScript.Registry.should be_an_instance_of SteamCodec::KeyValues
+        end
+    end
+
+    describe '#isSignaturesValid?' do
+        it 'should check if signature is valid' do
+            SteamCodec::VDF.new.isSignaturesValid?(nil).should be_true
+            SteamCodec::VDF::load(valveDataFile).isSignaturesValid?(nil).should be_false
+        end
+    end
+
+end

data/steam_codec.gemspec

@@ -1,4 +1,4 @@
-# coding: utf-8
+# encoding: UTF-8
 lib = File.expand_path('../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'steam_codec/version'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: steam_codec
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors:
 - Dāvis
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-09-16 00:00:00.000000000 Z
+date: 2013-09-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: insensitive_hash