tataru 0.1.0 → 0.2.0

data/spec/instructions/clear_instruction_spec.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'tataru'
+
+describe Tataru::Instructions::ClearInstruction do
+  it 'clears temp' do
+    mem = Tataru::Memory.new
+    instr = Tataru::Instructions::ClearInstruction.new
+
+    mem.hash[:temp] = { something: 'haha' }
+    instr.memory = mem
+    instr.run
+
+    expect(mem.hash[:temp]).to eq({})
+  end
+end

data/spec/instructions/compare_instruction_spec.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'tataru'
+
+describe Tataru::Instructions::CompareInstruction do
+  it 'sets to 1 if equal' do
+    mem = Tataru::Memory.new
+    instr = Tataru::Instructions::CompareInstruction.new('abc')
+
+    mem.hash[:temp] = { result: 'abc' }
+
+    instr.memory = mem
+    instr.run
+
+    expect(mem.hash[:temp][:result]).to eq 1
+  end
+
+  it 'sets to 0 if not equal' do
+    mem = Tataru::Memory.new
+    instr = Tataru::Instructions::CompareInstruction.new('def')
+
+    mem.hash[:temp] = { result: 'abc' }
+
+    instr.memory = mem
+    instr.run
+
+    expect(mem.hash[:temp][:result]).to eq 0
+  end
+end

data/spec/instructions/create_instruction_spec.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require 'tataru'
+
+describe Tataru::Instructions::CreateInstruction do
+  it 'sets remote id when needs remote id is true' do
+    mem = Tataru::Memory.new
+    instr = Tataru::Instructions::CreateInstruction.new
+
+    allow_any_instance_of(Tataru::BaseResourceDesc).to receive(:needs_remote_id?) { true }
+    expect_any_instance_of(Tataru::BaseResource).to receive(:create).with({ someprop: 'abc' })
+    allow_any_instance_of(Tataru::BaseResource).to receive(:remote_id) { 'someid' }
+
+    mem.hash[:temp] = {
+      resource_name: 'thing',
+      resource_desc: 'Tataru::BaseResourceDesc',
+      properties: { someprop: 'abc' }
+    }
+    mem.hash[:remote_ids] = {}
+    instr.memory = mem
+    instr.run
+
+    expect(mem.hash[:remote_ids]['thing']).to eq 'someid'
+  end
+
+  it 'does not set remote id if does not need remote id' do
+    mem = Tataru::Memory.new
+    instr = Tataru::Instructions::CreateInstruction.new
+
+    allow_any_instance_of(Tataru::BaseResourceDesc).to receive(:needs_remote_id?) { false }
+    expect_any_instance_of(Tataru::BaseResource).to receive(:create).with({ someprop: 'def' })
+
+    mem.hash[:temp] = {
+      resource_name: 'thing',
+      resource_desc: 'Tataru::BaseResourceDesc',
+      properties: { someprop: 'def' }
+    }
+    mem.hash[:remote_ids] = {}
+    instr.memory = mem
+
+    instr.run
+  end
+
+  xit 'throws error if remote_id already set' do
+    mem = Tataru::Memory.new
+    instr = Tataru::Instructions::CreateInstruction.new
+
+    allow_any_instance_of(Tataru::BaseResourceDesc).to receive(:needs_remote_id?) { true }
+    expect_any_instance_of(Tataru::BaseResource).to receive(:create).with({ someprop: 'abc' })
+    allow_any_instance_of(Tataru::BaseResource).to receive(:remote_id) { 'someid' }
+
+    mem.hash[:temp] = {
+      resource_name: 'thing',
+      resource_desc: 'Tataru::BaseResourceDesc',
+      properties: { someprop: 'abc' }
+    }
+    mem.hash[:remote_ids] = { 'thing' => 'def' }
+    instr.memory = mem
+
+    expect { instr.run }.to raise_error
+  end
+end

data/spec/instructions/delete_instruction_spec.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'tataru'
+
+describe Tataru::Instructions::DeleteInstruction do
+  it 'calls delete on the resource' do
+    mem = Tataru::Memory.new
+    instr = Tataru::Instructions::DeleteInstruction.new
+
+    mem.hash[:temp] = {
+      resource_name: 'thing',
+      resource_desc: 'Tataru::BaseResourceDesc'
+    }
+    mem.hash[:remote_ids] = { 'thing' => 'hello' }
+    instr.memory = mem
+
+    expect_any_instance_of(Tataru::BaseResource).to receive(:delete)
+    instr.run
+  end
+end

data/spec/instructions/end_instruction_spec.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'tataru'
+
+describe Tataru::Instructions::EndInstruction do
+  it 'sets end to true' do
+    mem = Tataru::Memory.new
+    instr = Tataru::Instructions::EndInstruction.new
+
+    instr.memory = mem
+    instr.run
+
+    expect(mem.end).to eq true
+  end
+end

data/spec/instructions/goto_if_instruction_spec.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require 'tataru'
+
+describe Tataru::Instructions::GotoIfInstruction do
+  it 'branches if result is non zero' do
+    mem = Tataru::Memory.new
+    instr = Tataru::Instructions::GotoIfInstruction.new(5)
+
+    mem.hash[:temp] = { result: 1 }
+
+    instr.memory = mem
+    instr.run
+
+    expect(mem.program_counter).to eq 4
+  end
+
+  it 'does nothing if result is zero' do
+    mem = Tataru::Memory.new
+    instr = Tataru::Instructions::GotoIfInstruction.new(6)
+
+    mem.hash[:temp] = { result: 0 }
+
+    instr.memory = mem
+    instr.run
+
+    expect(mem.program_counter).to eq 0
+  end
+
+  it 'goes to label if param is label' do
+    mem = Tataru::Memory.new
+    instr = Tataru::Instructions::GotoIfInstruction.new('function')
+
+    mem.hash[:labels] = { 'function' => 10 }
+    mem.hash[:temp] = { result: 1 }
+
+    instr.memory = mem
+    instr.run
+
+    expect(mem.program_counter).to eq 9
+  end
+end

data/spec/instructions/init_instruction_spec.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'tataru'
+
+describe Tataru::Instructions::InitInstruction do
+  it 'sets hashes' do
+    instr = Tataru::Instructions::InitInstruction.new
+    mem = Tataru::Memory.new
+    instr.memory = mem
+    instr.run
+    expect(mem.hash.key? :remote_ids).to eq true
+    expect(mem.hash.key? :outputs).to eq true
+    expect(mem.hash.key? :labels).to eq true
+    expect(mem.hash.key? :deleted).to eq true
+  end
+end

data/spec/instructions/key_instruction_spec.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'tataru'
+
+describe Tataru::Instructions::KeyInstruction do
+  it 'set a key' do
+    mem = Tataru::Memory.new
+    instr = Tataru::Instructions::KeyInstruction.new('meow')
+
+    instr.memory = mem
+    instr.run
+
+    expect(mem.hash[:temp]).to eq(_key: 'meow')
+  end
+end

data/spec/instructions/mark_deletable_instruction_spec.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'tataru'
+
+describe Tataru::Instructions::MarkDeletableInstruction do
+  it 'set a resource as deletable' do
+    mem = Tataru::Memory.new
+    instr = Tataru::Instructions::MarkDeletableInstruction.new
+
+    mem.hash[:temp] = {
+      resource_name: 'thing',
+      resource_desc: 'Tataru::BaseResourceDesc'
+    }
+    mem.hash[:remote_ids] = { 'thing' => 'hello' }
+    instr.memory = mem
+    instr.run
+
+    expect(mem.hash[:remote_ids]).to eq('_deletable_thing' => 'hello')
+  end
+end

data/spec/instructions/read_instruction_spec.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require 'tataru'
+
+describe Tataru::Instructions::ReadInstruction do
+  it 'sets hashes' do
+    mem = Tataru::Memory.new
+    instr = Tataru::Instructions::ReadInstruction.new
+
+    mem.hash[:temp] = {
+      resource_name: 'thing',
+      resource_desc: 'Tataru::BaseResourceDesc'
+    }
+    mem.hash[:remote_ids] = { 'thing' => 'hello' }
+    instr.memory = mem
+
+    expect_any_instance_of(Tataru::BaseResourceDesc).to receive(:immutable_fields) { [:prop1] }
+    expect_any_instance_of(Tataru::BaseResourceDesc).to receive(:mutable_fields) { [:prop2] }
+
+    expect_any_instance_of(Tataru::BaseResource).to receive(:read).with([:prop1, :prop2]) do
+      {
+        prop1: 'info',
+        prop2: '1234',
+        extra: 'notseen'
+      }
+    end
+    instr.run
+
+    expect(mem.hash[:temp]['thing']).to eq(
+      prop1: 'info',
+      prop2: '1234'
+    )
+  end
+end

data/spec/instructions/rescmp_instruction_spec.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+require 'tataru'
+
+describe Tataru::Instructions::RescmpInstruction do
+  # compares temp with rom properties
+  # sets no_change, update, recreate
+
+  it 'sets temp result to no_change if there are no changes' do
+    mem = Tataru::Memory.new
+    instr = Tataru::Instructions::RescmpInstruction.new
+
+    allow_any_instance_of(Tataru::BaseResourceDesc).to receive(:mutable_fields) { [:prop] }
+
+    mem.hash[:rom] = {
+      'thing' => {
+        type: :hash,
+        references: {
+          :prop => 'literal'
+        }
+      },
+      'literal' => {
+        type: :literal,
+        value: 'info'
+      }
+    }
+
+    mem.hash[:temp] = {
+      resource_name: 'thing',
+      resource_desc: 'Tataru::BaseResourceDesc',
+      'thing' => {
+        prop: 'info'
+      }
+    }
+
+    mem.hash[:update_action] = {}
+
+    instr.memory = mem
+    instr.run
+
+    expect(mem.hash[:update_action]['thing']).to eq :no_change
+  end
+
+  it 'sets temp result to modify if there are changes to mutable' do
+    mem = Tataru::Memory.new
+    instr = Tataru::Instructions::RescmpInstruction.new
+
+    allow_any_instance_of(Tataru::BaseResourceDesc).to receive(:mutable_fields) { [:prop] }
+
+    mem.hash[:rom] = {
+      'thing' => {
+        type: :hash,
+        references: {
+          :prop => 'literal'
+        }
+      },
+      'literal' => {
+        type: :literal,
+        value: 'AAAA'
+      }
+    }
+
+    mem.hash[:temp] = {
+      resource_name: 'thing',
+      resource_desc: 'Tataru::BaseResourceDesc',
+      'thing' => {
+        prop: 'BBBB'
+      }
+    }
+
+    mem.hash[:update_action] = {}
+
+    instr.memory = mem
+    instr.run
+
+    expect(mem.hash[:update_action]['thing']).to eq :modify
+  end
+
+  it 'sets temp result to recreate if there are changes to immutable' do
+    mem = Tataru::Memory.new
+    instr = Tataru::Instructions::RescmpInstruction.new
+
+    allow_any_instance_of(Tataru::BaseResourceDesc).to receive(:immutable_fields) { [:prop] }
+
+    mem.hash[:rom] = {
+      'thing' => {
+        type: :hash,
+        references: {
+          :prop => 'literal'
+        }
+      },
+      'literal' => {
+        type: :literal,
+        value: 'AAAAA'
+      }
+    }
+
+    mem.hash[:temp] = {
+      resource_name: 'thing',
+      resource_desc: 'Tataru::BaseResourceDesc',
+      'thing' => {
+        prop: 'BBNBB'
+      }
+    }
+
+    mem.hash[:update_action] = {}
+
+    instr.memory = mem
+    instr.run
+
+    expect(mem.hash[:update_action]['thing']).to eq :recreate
+  end
+end

data/spec/instructions/return_instruction_spec.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'tataru'
+
+describe Tataru::Instructions::ReturnInstruction do
+  it 'return to top of stack' do
+    mem = Tataru::Memory.new
+    instr = Tataru::Instructions::ReturnInstruction.new
+
+    mem.call_stack = [1, 2, 3]
+    instr.memory = mem
+    instr.run
+
+    expect(mem.program_counter).to eq 3
+  end
+
+  it 'sets error if no more stack' do
+    mem = Tataru::Memory.new
+    mem.call_stack = []
+    instr = Tataru::Instructions::ReturnInstruction.new
+
+    instr.memory = mem
+    instr.run
+
+    expect(mem.program_counter).to eq 0
+    expect(mem.error).to eq 'At bottom of stack'
+  end
+end

data/spec/instructions/update_instruction_spec.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require 'tataru'
+
+describe Tataru::Instructions::UpdateInstruction do
+  it 'calls update' do
+    mem = Tataru::Memory.new
+    instr = Tataru::Instructions::UpdateInstruction.new
+
+    mem.hash[:temp] = {
+      resource_name: 'thing',
+      resource_desc: 'Tataru::BaseResourceDesc',
+      properties: { 'someprop' => 'somevalue' }
+    }
+
+    mem.hash[:remote_ids] = { 'thing' => 'hello' }
+    instr.memory = mem
+    expect_any_instance_of(Tataru::BaseResource).to receive(:update).with('someprop' => 'somevalue')
+    
+    instr.run
+  end
+
+  xit 'should throw error if an immutable prop is changed' do
+    mem = Tataru::Memory.new
+    instr = Tataru::Instructions::UpdateInstruction.new
+
+    expect_any_instance_of(Tataru::BaseResourceDesc).to receive(:immutable_fields) { ['someprop'] }
+
+    mem.hash[:temp] = {
+      resource_name: 'thing',
+      resource_desc: 'Tataru::BaseResourceDesc',
+      properties: { 'someprop' => 'somevalue' }
+    }
+    mem.hash[:remote_ids] = { 'thing' => 'hello' }
+    instr.memory = mem
+
+    expect { instr.run }.to raise_error 'immutable value changed'
+  end
+end