lunar_cheese 0.2.3

data/lib/lunar_cheese/grammar.treetop

@@ -0,0 +1,45 @@
+module LunarCheese
+    grammar LuaTableDump
+
+        rule table
+            '{' child:(assignment / value)? other_children:(',' child:(assignment / value))* '}' <AST::LuaTable>
+        end
+
+        rule prefix
+            '+' / '-'
+        end
+
+        rule integer
+            prefix? [0-9]+ <AST::IntegerLiteral>
+        end
+
+        rule float
+            integer '.' [0-9]+ <AST::FloatLiteral>
+        end
+
+        rule boolean
+            'false' <AST::BooleanLit>
+            /
+            'true' <AST::BooleanLit>
+        end
+
+        rule string
+            '"' text:('\"' / !'"' .)* '"' <AST::StringLiteral>
+        end
+
+        rule identifier
+           [a-zA-Z_] [a-zA-Z0-9_]* <AST::IdentifierLiteral>
+            /
+            '[' [^\[\]]+ ']' <AST::IdentifierLiteral>
+        end
+
+        rule value
+            (float / integer / string / boolean / table)
+        end
+
+        rule assignment
+            identifier '=' value <AST::Assignment>
+        end
+
+    end
+end

data/lunar_cheese.gemspec

@@ -0,0 +1,20 @@
+#coding: utf-8
+
+Gem::Specification.new do |s|
+    s.name = 'lunar_cheese'
+    s.version = '0.2.3'
+    s.summary = 'Treetop grammar & additions to core classes to convert "Don\'t Starve" save games to Ruby and vice versa.'
+    s.description = 'A gem consisting of two parts: A Treetop-based grammar which allows to parse save games of the game "Don\'t Starve" to Ruby objects, and additions to Ruby core classes to dump those back into the same format.'
+
+    s.author = 'Michael Senn'
+    s.email = 'morrolan@morrolan.ch'
+    s.homepage = 'https://bitbucket.org/Lavode/lunar-cheese'
+    s.license = 'Apache 2.0'
+
+    s.files = `git ls-files`.split("\n")
+    s.test_files = `git ls-files spec/`.split("\n")
+
+    s.add_dependency 'treetop'
+
+    s.add_development_dependency 'rspec'
+end

data/spec/lunar_cheese/assignments_spec.rb

@@ -0,0 +1,71 @@
+#coding: utf-8
+
+require_relative '../spec_helper'
+
+module LunarCheese
+
+  describe LuaTableDumpParser do
+    let(:p) { LuaTableDumpParser.new }
+
+    context 'parsing' do
+      before(:each) { p.root = :assignment }
+
+      context 'valid assignments' do
+
+        it 'should parse assignments of numerics' do
+          expect(parse('x=12')).to eq({ :x => 12 })
+          expect(parse('foo=21.5')).to eq({ :foo => 21.5 })
+          expect(parse('salary=9.5')).to eq({ :salary => 9.5 })
+          expect(parse('[3]=15.345')).to eq({ :'[3]' => 15.345 })
+        end
+
+        it 'should parse assignments of strings' do
+          expect(parse('race="Human"')).to eq({ :race => 'Human' })
+          expect(parse('greeting="Hello World!"')).to eq({ :greeting => 'Hello World!' })
+          expect(parse('[e=]="m*c^2"')).to eq({ :'[e=]' => 'm*c^2' })
+        end
+
+        it 'should parse assignments of booleans' do
+          expect(parse('is_working=true')).to eq({ :is_working => true })
+          expect(parse('on_fire=false')).to eq({ :on_fire => false })
+          expect(parse('[x && true]=true')).to eq({ :'[x && true]' => true })
+        end
+
+        it 'should parse assignment of tables' do
+          expect(parse('person={name="John",age=55}')).to eq({ :person => { :name => 'John', :age => 55 } })
+          expect(parse('coords={10,5,10}')).to eq({ :coords => { 0 => 10, 1 => 5, 2 => 10 } })
+          expect(parse('coords={foo="bar",1,2}')).to eq({ :coords => { :foo => 'bar', 0 => 1, 1 => 2 } })
+        end
+
+      end
+
+      context 'invalid assignments' do
+
+        it 'should not parse assignments which are missing the lhs' do
+          expect(parse('=3')).to be_nil
+        end
+
+        it 'should not parse assignments which are missing the rhs' do
+          expect(parse('foo=')).to be_nil
+        end
+
+        it "should not parse assignments without an 'equals' sign" do
+          expect(parse('foo123')).to be_nil
+        end
+
+        it "should not parse assignments with multiple 'equals' signs" do
+          expect(parse('foo=="bar"')).to be_nil
+          expect(parse('foo="bar"="baz"')).to be_nil
+        end
+
+        it "should not parse the 'equals' sign alone" do
+          expect(parse('=')).to be_nil
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/spec/lunar_cheese/booleans_spec.rb

@@ -0,0 +1,40 @@
+#coding: utf-8
+
+require_relative '../spec_helper'
+
+module LunarCheese
+
+  describe LuaTableDumpParser do
+    let(:p) { LuaTableDumpParser.new }
+
+    context 'parsing' do
+      before(:each) { p.root = :boolean }
+
+      it 'should parse booleans' do
+        result = parse('false')
+        expect(result).to be_false
+        expect(result).to_not be_nil
+
+        expect(parse('true')).to be_true
+      end
+
+      it 'should not parse invalid booleans' do
+        expect(parse('False')).to be_nil
+        expect(parse('True')).to be_nil
+        expect(parse('fAtrue')).to be_nil
+      end
+
+    end
+
+    context 'dumping' do
+
+      it 'should dump booleans' do
+        expect(false.to_lua).to eq 'false'
+        expect(true.to_lua).to eq 'true'
+      end
+
+    end
+
+  end
+
+end

data/spec/lunar_cheese/floats_spec.rb

@@ -0,0 +1,67 @@
+#coding: utf-8
+
+require_relative '../spec_helper'
+
+module LunarCheese
+
+  describe LuaTableDumpParser do
+    let(:p) { LuaTableDumpParser.new }
+
+    context 'parsing' do
+      before(:each) { p.root = :float }
+
+      context 'valid floats' do
+
+        it 'should parse basic floats' do
+          expect(parse('0.512')).to eq 0.512
+          expect(parse('21.27')).to eq 21.27
+          expect(parse('0.00')).to eq  0
+        end
+
+        it 'should parse floats with a prefix' do
+          expect(parse('-193.2')).to eq -193.2
+          expect(parse('+9.1')).to eq 9.1
+          expect(parse('-211.286')).to eq -211.286
+        end
+
+      end
+
+      context 'invalid floats' do
+
+        it 'should not parse floats with more than one period' do
+          expect(parse('15..6')).to be_nil
+          expect(parse('14.5.7')).to be_nil
+        end
+
+        it 'should not parse floats with a period in the beginning or end' do
+          expect(parse('132.')).to be_nil
+          expect(parse('.25')).to be_nil
+        end
+
+      end
+
+    end
+
+    context 'dumping' do
+
+      it 'should dump basic floats' do
+        expect(0.0.to_lua).to eq '0.0'
+        expect(928.51.to_lua).to eq '928.51'
+      end
+
+      it 'should dump floats with a prefix' do
+        expect(-50.2.to_lua).to eq '-50.2'
+        expect(-21.5.to_lua).to eq '-21.5'
+      end
+
+      it 'should not print the prefix for numbers >= 0' do
+        expect(-0.to_lua).to eq '0'
+        expect(0.5.to_lua).to eq '0.5'
+        expect(+213.21.to_lua).to eq '213.21'
+      end
+
+    end
+
+  end
+
+end

data/spec/lunar_cheese/identifiers_spec.rb

@@ -0,0 +1,63 @@
+#coding: utf-8
+
+require_relative '../spec_helper'
+
+module LunarCheese
+
+  describe LuaTableDumpParser do
+    let(:p) { LuaTableDumpParser.new }
+
+    context 'parsing' do
+      before(:each) { p.root = :identifier }
+
+      context 'valid identifiers' do
+
+        it 'should parse identifiers' do
+          expect(parse('x')).to eq :x
+          expect(parse('age')).to eq :age
+          expect(parse('last_name')).to eq :last_name
+        end
+
+        it 'should parse identifiers in brackets' do
+          expect(parse('[1]')).to eq :'[1]'
+          expect(parse('[25]')).to eq :'[25]'
+          expect(parse('[*]')).to eq :'[*]'
+          expect(parse('[liar liar pants on fire!]')).to eq :'[liar liar pants on fire!]'
+        end
+
+      end
+
+      context 'invalid identifiers' do
+
+        it 'should not parse non-alphanumeric (+underscore) identifiers without brackets' do
+          expect(parse('ab*c')).to be_nil
+          expect(parse('foo-bar_baz')).to be_nil
+          expect(parse('Hello there. :D')).to be_nil
+        end
+
+      end
+
+    end
+
+    context 'dumping' do
+
+      it 'should dump alphanumeric (+underscore) identifiers' do
+        expect(:last_name.to_lua).to eq 'last_name'
+        expect(:age.to_lua).to eq 'age'
+      end
+
+      it 'should dump non-alphanumeric (+underscore) identifiers' do
+        expect(:'e=m*c^2'.to_lua).to eq '[e=m*c^2]'
+        expect(:'a big horse'.to_lua).to eq '[a big horse]'
+      end
+
+      it 'should dump identifiers inside square brackets' do
+        expect(:'[1]'.to_lua).to eq '[1]'
+        expect(:'[liar liar pants on fire!]'.to_lua).to eq '[liar liar pants on fire!]'
+      end
+
+    end
+
+  end
+
+end

data/spec/lunar_cheese/integers_spec.rb

@@ -0,0 +1,85 @@
+#coding: utf-8
+
+require_relative '../spec_helper'
+
+module LunarCheese
+
+  describe LuaTableDumpParser do
+    let(:p) { LuaTableDumpParser.new }
+
+    context 'parsing' do
+      before(:each) { p.root = :integer }
+
+      context 'valid integers' do
+
+        it 'should parse basic integers' do
+          expect(parse('0')).to eq 0
+          expect(parse('21')).to eq 21
+          expect(parse('928')).to eq 928
+        end
+
+        it 'should parse integers with a prefix' do
+          expect(parse('+0')).to eq 0
+          expect(parse('-0')).to eq 0
+          expect(parse('+216')).to eq 216
+          expect(parse('-31')).to eq -31
+        end
+
+      end
+
+      context 'invalid integers' do
+
+        it 'should not parse integers with more than one prefix' do
+          expect(parse('--21')).to be_nil
+          expect(parse('-+18')).to be_nil
+          expect(parse('+-157')).to be_nil
+          expect(parse('++24')).to be_nil
+        end
+
+        it 'should not parse integers with an invalid prefix' do
+          expect(parse('*21')).to be_nil
+          expect(parse('§18')).to be_nil
+        end
+
+        it 'should not parse integers with a prefix anywhere but the very beginning' do
+          expect(parse('2+1')).to be_nil
+          expect(parse('-14+5')).to be_nil
+        end
+
+        it 'should not parse prefixes alone' do
+          expect(parse('-')).to be_nil
+          expect(parse('+')).to be_nil
+        end
+
+        it 'should not parse integers which consist of non-numeric characters' do
+          expect(parse('12a')).to be_nil
+          expect(parse('a51§')).to be_nil
+        end
+
+      end
+
+    end
+
+    context 'dumping' do
+
+      it 'should dump basic integers' do
+        expect(0.to_lua).to eq '0'
+        expect(928.to_lua).to eq '928'
+      end
+
+      it 'should dump integers with a prefix' do
+        expect(-50.to_lua).to eq '-50'
+        expect(-21.to_lua).to eq '-21'
+      end
+
+      it 'should not print the prefix for numbers >= 0' do
+        expect(-0.to_lua).to eq '0'
+        expect(0.to_lua).to eq '0'
+        expect(+213.to_lua).to eq '213'
+      end
+
+    end
+
+  end
+
+end

data/spec/lunar_cheese/strings_spec.rb

@@ -0,0 +1,81 @@
+#coding: utf-8
+
+require_relative '../spec_helper'
+
+module LunarCheese
+
+  describe LuaTableDumpParser do
+    let(:p) { LuaTableDumpParser.new }
+
+    context 'parsing' do
+      before(:each) { p.root = :string }
+
+      context 'valid strings' do
+
+        it 'should parse empty strings' do
+          expect(parse('""')).to eq ''
+        end
+
+        it 'should parse alphanumeric one-word strings' do
+          expect(parse('"foobar"')).to eq 'foobar'
+          expect(parse('"Michael"')).to eq 'Michael'
+          expect(parse('"Parsing4Life"')).to eq 'Parsing4Life'
+        end
+
+        it 'should parse non-alphanumeric strings' do
+          expect(parse('"@¼|¬§éLA12^"')).to eq '@¼|¬§éLA12^'
+          expect(parse('"l\'église"')).to eq "l'église"
+        end
+
+        it 'should parse multi-word strings' do
+          expect(parse('"Hello world, how are you today?"')).to eq 'Hello world, how are you today?'
+          expect(parse('"e = m * c ^ 2"')).to eq 'e = m * c ^ 2'
+        end
+
+        it 'should parse strings with escaped quotation marks' do
+          expect(parse('"He called her \"Honeymoon\""')).to eq 'He called her "Honeymoon"'
+          expect(parse('"Yes, \"John\" is his name, now kill him!"')).to eq 'Yes, "John" is his name, now kill him!'
+        end
+
+      end
+
+      context 'invalid strings' do
+
+        it 'should not parse strings without quotation marks' do
+          expect(parse('hello there')).to be_nil
+          expect(parse('but I want to be parsed D:')).to be_nil
+        end
+
+        it 'should not parse strings with the leading or trailing quotation mark missing' do
+          expect(parse('"Hello wor...')).to be_nil
+          expect(parse('..lo world"')).to be_nil
+        end
+
+        it 'should not parse strings with non-escaped quotation marks' do
+          expect(parse('"He called her \"Honeymoon""')).to be_nil
+          expect(parse('"Yes, "John\" is his name, now kill him!"')).to be_nil
+        end
+
+      end
+
+    end
+
+    context 'dumping' do
+
+      it 'should dump empty strings' do
+        expect(''.to_lua).to eq '""'
+      end
+
+      it 'should dump strings' do
+        expect('Hello World!'.to_lua).to eq '"Hello World!"'
+      end
+
+      it 'should escape quotation marks' do
+        expect('He called her "Honeymoon"'.to_lua).to eq '"He called her \"Honeymoon\""'
+      end
+
+    end
+
+  end
+
+end