gisele-vm 0.6.0

data/spec/unit/bytecode/grammar/test_block.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+module Gisele
+  class VM
+    describe Bytecode::Grammar, "block" do
+
+      def parse(src)
+        Bytecode::Grammar.parse(src, :root => :block)
+      end
+
+      it 'parses a block with one instruction' do
+        expected = [:block, 0, [:dump] ]
+        parse(<<-BLOCK.strip).value.should eq(expected)
+          0:  dump
+        BLOCK
+      end
+
+      it 'parses a block with two instructions' do
+        expected = [:block, 0, [:dump], [:pop, 3] ]
+        parse(<<-BLOCK.strip).value.should eq(expected)
+          0:  dump
+              pop 3
+        BLOCK
+      end
+
+      it 'supports comments' do
+        expected = [:block, 0, [:dump], [:pop, 3] ]
+        parse(<<-BLOCK.strip).value.should eq(expected)
+          0:  dump     # blah
+              pop 3    # blih
+        BLOCK
+      end
+
+    end
+  end
+end

data/spec/unit/bytecode/grammar/test_boolean.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+module Gisele
+  class VM
+    describe Bytecode::Grammar, "boolean" do
+
+      def parse(src)
+        Bytecode::Grammar.parse(src, :root => :boolean)
+      end
+
+      it 'parses true' do
+        parse("true").value.should eq(true)
+      end
+
+      it 'parses false' do
+        parse("false").value.should eq(false)
+      end
+
+    end
+  end
+end

data/spec/unit/bytecode/grammar/test_constant.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+module Gisele
+  class VM
+    describe Bytecode::Grammar, "constant" do
+
+      def parse(src)
+        Bytecode::Grammar.parse(src, :root => :constant)
+      end
+
+      it 'parses single constants correctly' do
+        parse("Integer").value.should eq(Integer)
+      end
+
+      it 'parses qualified constants correctly' do
+        parse("Gisele::VM").value.should eq(Gisele::VM)
+      end
+
+    end
+  end
+end

data/spec/unit/bytecode/grammar/test_eol.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+module Gisele
+  class VM
+    describe Bytecode::Grammar, "eol" do
+
+      def parse(src)
+        Bytecode::Grammar.parse(src, :root => :eol)
+      end
+
+      it 'parses \n' do
+        parse("\n").value.should eq("\n")
+      end
+
+      it 'parses eof' do
+        parse("").value.should eq("")
+      end
+
+    end
+  end
+end

data/spec/unit/bytecode/grammar/test_eol_comment.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+module Gisele
+  class VM
+    describe Bytecode::Grammar, "eol_comment" do
+
+      def parse(src)
+        Bytecode::Grammar.parse(src, :root => :eol_comment)
+      end
+
+      it 'parses a comment, including the \n' do
+        parse("# hello\n").should eq("# hello\n")
+      end
+
+      it 'parses a comment, if no \n but eof' do
+        parse("# hello").should eq("# hello")
+      end
+
+      it 'parses an empty comment' do
+        parse("#\n").should eq("#\n")
+      end
+
+      it 'raise a parse if trailing' do
+        lambda{
+          parse("bblh # hello\ntrailing")
+        }.should raise_error(Citrus::ParseError)
+      end
+
+      it 'raise a parse error otherwise' do
+        lambda{
+          parse("bblh # hello")
+        }.should raise_error(Citrus::ParseError)
+      end
+
+    end
+  end
+end

data/spec/unit/bytecode/grammar/test_file.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+module Gisele
+  class VM
+    describe Bytecode::Grammar, "file" do
+
+      def parse(src)
+        Bytecode::Grammar.parse(src)
+      end
+
+      it 'returns a [:gvm] array' do
+        expected = \
+          [:gvm,
+            [ :block, 0, [:dump], [:pop, 3] ],
+            [ :block, 1, [:hello] ] ]
+        parse(<<-BLOCK.strip).value.should eq(expected)
+          0: dump
+             pop 3
+          1: hello
+        BLOCK
+      end
+
+      (Path.dir/'fixtures').glob('*.gvm').each do |file|
+        context "the fixture #{File.basename(file)}" do
+          let(:sexpr){ Bytecode::Grammar.sexpr(file) }
+
+          it "is parsed correctly" do
+            sexpr.should be_a(Array)
+          end
+
+          it "respects the grammar" do
+            (Bytecode::Grammar === sexpr).should be_true
+          end
+        end
+      end
+
+    end
+  end
+end

data/spec/unit/bytecode/grammar/test_hash.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+module Gisele
+  class VM
+    describe Bytecode::Grammar, "hash" do
+
+      def parse(src)
+        Bytecode::Grammar.parse(src, :root => :hash)
+      end
+
+      it 'parses empty hashes correctly' do
+        parse("{}").value.should eq({})
+      end
+
+      it 'parses singletons correctly' do
+        parse("{key: 12}").value.should eq({:key => 12})
+      end
+
+      it 'parses hashes correctly' do
+        parse("{key: 12, name: 'blaj'}").value.should eq({:key => 12, :name => 'blaj'})
+      end
+
+      it 'parses event dict' do
+        expected = {:hello => :s2, :goodbye => :s3}
+        parse("{hello: :s2, goodbye: :s3}").value.should eq(expected)
+      end
+
+      it 'supports 1.8 syntax' do
+        parse("{:key => 12, :name => 'blaj'}").value.should eq({:key => 12, :name => 'blaj'})
+      end
+
+    end
+  end
+end

data/spec/unit/bytecode/grammar/test_instruction.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+module Gisele
+  class VM
+    describe Bytecode::Grammar, "instruction" do
+
+      def parse(src)
+        Bytecode::Grammar.parse(src, :root => :instruction)
+      end
+
+      it 'parses an instruction without arg' do
+        parse("dump").value.should eq([:dump])
+      end
+
+      it 'parses an instruction with an arg' do
+        parse("dump 0").value.should eq([:dump, 0])
+      end
+
+      it 'parses an instruction with two args' do
+        parse("dump 0, 'blah'").value.should eq([:dump, 0, "blah"])
+      end
+
+      it 'supports tailing spaces' do
+        parse("dump 0, 'blah'    ").value.should eq([:dump, 0, "blah"])
+      end
+
+      it 'supports comments' do
+        parse("dump 0, 'blah'   # a comment").value.should eq([:dump, 0, "blah"])
+      end
+
+    end
+  end
+end

data/spec/unit/bytecode/grammar/test_int.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+module Gisele
+  class VM
+    describe Bytecode::Grammar, "int" do
+
+      def parse(src)
+        Bytecode::Grammar.parse(src, :root => :int)
+      end
+
+      it 'parses positive integers correctly' do
+        parse("101").value.should eq(101)
+      end
+
+      it 'parses negative integers correctly' do
+        parse("-101").value.should eq(-101)
+      end
+
+      it 'parses 0' do
+        parse("0").value.should eq(0)
+      end
+
+    end
+  end
+end

data/spec/unit/bytecode/grammar/test_label.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+module Gisele
+  class VM
+    describe Bytecode::Grammar, "label" do
+
+      def parse(src)
+        Bytecode::Grammar.parse(src, :root => :label)
+      end
+
+      it 'parses a label, including the :' do
+        parse("alabel:").value.should eq(:alabel)
+      end
+
+      it 'allows pure numerics' do
+        parse("0:").value.should eq(0)
+      end
+
+      it 'allows pure alphanums' do
+        parse("blah0:").value.should eq(:blah0)
+      end
+
+    end
+  end
+end

data/spec/unit/bytecode/grammar/test_opcode.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+module Gisele
+  class VM
+    describe Bytecode::Grammar, "opcode" do
+
+      def parse(src)
+        Bytecode::Grammar.parse(src, :root => :opcode)
+      end
+
+      it 'parses typical opcodes' do
+        parse("dump").value.should eq(:dump)
+        parse("pop").value.should eq(:pop)
+      end
+
+      it 'does not allow numerics' do
+        lambda{
+          parse('pop0')
+        }.should raise_error(Citrus::ParseError)
+      end
+
+    end
+  end
+end

data/spec/unit/bytecode/grammar/test_string.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+module Gisele
+  class VM
+    describe Bytecode::Grammar, "string" do
+
+      def parse(src)
+        Bytecode::Grammar.parse(src, :root => :string)
+      end
+
+      it 'parses single quoted strings' do
+        parse("'hello'").value.should eq("hello")
+      end
+
+      it 'parses double quoted strings' do
+        parse('"hello"').value.should eq("hello")
+      end
+
+      it 'parses empty strings' do
+        parse("''").value.should eq("")
+        parse('""').value.should eq("")
+      end
+
+    end
+  end
+end

data/spec/unit/bytecode/grammar/test_symbol.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+module Gisele
+  class VM
+    describe Bytecode::Grammar, "symbol" do
+
+      def parse(src)
+        Bytecode::Grammar.parse(src, :root => :symbol)
+      end
+
+      it 'parses alphabetic symbols' do
+        parse(":abc").value.should eq(:abc)
+      end
+
+      it 'parses alphanums' do
+        parse(":ab0c").value.should eq(:ab0c)
+      end
+
+      it 'allows capitals' do
+        parse(":AB0C").value.should eq(:AB0C)
+      end
+
+      it 'requires a letter as first char' do
+        lambda{
+          parse('0ab')
+        }.should raise_error(Citrus::ParseError)
+      end
+
+    end
+  end
+end

data/spec/unit/bytecode/test_build.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+module Gisele
+  class VM
+    describe Bytecode, '.build' do
+
+      subject{
+        Bytecode.build(namespace) do |b|
+          b.at(:s0) do
+            b.push 12
+          end
+        end
+      }
+
+      context 'without namespace' do
+        let(:namespace){ nil }
+
+        it 'returns a Bytecode instance' do
+          subject.should be_a(Bytecode)
+        end
+
+        it 'builds bytecode' do
+          subject[:s0].should eq([ [:push, 12] ])
+        end
+      end
+
+      context 'with a namespace' do
+        let(:namespace){ "Somewhere" }
+
+        it 'uses namespaced labels' do
+          subject[:"Somewhere_s0"].should eq([ [:push, 12] ])
+        end
+      end
+
+    end
+  end
+end

data/spec/unit/bytecode/test_coerce.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+module Gisele
+  class VM
+    describe Bytecode, '.coerce' do
+
+      def coerce(source)
+        @result = Bytecode.coerce(source)
+      end
+
+      after do
+        @result.should be_a(Bytecode) if @result
+      end
+
+      it 'coerces bytecode' do
+        coerce(Bytecode.new [:gvm])
+      end
+
+      it 'coerces a String' do
+        coerce("s0: push 12")
+      end
+
+      it 'coerces a .gvm Path' do
+        coerce(fixtures/'ts.gvm')
+      end
+
+      it 'coerces a valid parse result' do
+        coerce(Bytecode::Grammar.sexpr(fixtures/'ts.gvm'))
+      end
+
+      it 'raises an InvalidBytecodeError when not recognized' do
+        lambda{
+          coerce(self)
+        }.should raise_error(ArgumentError)
+        lambda{
+          coerce([:gvm, [:block, :s0, [:puts]]])
+        }.should raise_error(ArgumentError)
+      end
+
+    end
+  end
+end