tataru 0.1.0 → 0.2.0

data/spec/flattener_spec.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require 'tataru'
+
+describe Tataru::Flattener do
+  it 'flattens literals' do
+    f = Tataru::Flattener.new(Tataru::Representations::LiteralRepresentation.new('meow'))
+    expect(f.flattened).to eq(
+      top: {
+        type: :literal,
+        value: 'meow'
+      }
+    )
+  end
+
+  it 'flattens arrays' do
+    f = Tataru::Flattener.new(Tataru::Representations::ArrayRepresentation.new(['meow']))
+    expect(f.flattened).to eq(
+      top: {
+        type: :array,
+        references: {
+          0 => :top_0
+        }
+      },
+      top_0: {
+        type: :literal,
+        value: 'meow'
+      }
+    )
+  end
+
+  it 'flattens hashes' do
+    f = Tataru::Flattener.new(Tataru::Representations::HashRepresentation.new({somefield: 'somevalue'}))
+    expect(f.flattened).to eq(
+      top: {
+        type: :hash,
+        references: {
+          somefield: :top_somefield
+        }
+      },
+      top_somefield: {
+        type: :literal,
+        value: 'somevalue'
+      }
+    )
+  end
+
+  it 'flattens resources' do
+    f = Tataru::Flattener.new(Tataru::Representations::ResourceRepresentation.new('thing', Tataru::BaseResourceDesc.new, {}))
+    expect(f.flattened).to eq(
+      top: {
+        type: :hash,
+        references: {}
+      }
+    )
+  end
+
+  it 'flattens outputs' do
+    f = Tataru::Flattener.new(Tataru::Representations::OutputRepresentation.new('employee', 'age'))
+    expect(f.flattened).to eq(
+      top: {
+        type: :output,
+        resource: 'employee',
+        output: 'age'
+      }
+    )
+  end
+
+  it 'flattens resources that have properties' do
+    f = Tataru::Flattener.new(Tataru::Representations::ResourceRepresentation.new(
+      'thing',
+      Tataru::BaseResourceDesc.new,
+      { somefield: Tataru::Representations::LiteralRepresentation.new('somevalue') }
+    ))
+    expect(f.flattened).to eq(
+      top: {
+        type: :hash,
+        references: {
+          somefield: :top_somefield
+        }
+      },
+      top_somefield: {
+        type: :literal,
+        value: 'somevalue'
+      }
+    )
+  end
+end

data/spec/init_hash_compiler_spec.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require 'tataru'
+
+describe Tataru::InitHashCompiler do
+  it 'resolves references' do
+    dsl = Tataru::TopDsl.new(Tataru::ResourceTypePool.new)
+    ihc = Tataru::InitHashCompiler.new(dsl)
+
+    refs = {
+      aaa: 'top_thing',
+      bbb: 'top'
+    }
+
+    expect(ihc.resolved_references('resname', refs)).to eq(
+      aaa: 'resname_thing',
+      bbb: 'resname'
+    )
+  end
+
+  it 'generates an init hash' do
+    dsl = Tataru::TopDsl.new(Tataru::ResourceTypePool.new)
+    ihc = Tataru::InitHashCompiler.new(dsl)
+
+    expect(ihc.generate_init_hash).to eq(rom: {}, remote_ids: {})
+  end
+
+  it 'generates hashes for each resource' do
+    dsl = Tataru::TopDsl.new(Tataru::ResourceTypePool.new)
+    ihc = Tataru::InitHashCompiler.new(dsl)
+
+    rr = Tataru::Representations::ResourceRepresentation.new('file', Tataru::BaseResourceDesc.new, {})
+    allow(dsl).to receive(:resources) { { 'file1' => rr } }
+
+    allow_any_instance_of(Tataru::Flattener).to receive(:flattened) do
+      {
+        'abc' => {
+          type: :teststuff
+        }
+      }
+    end
+
+    expect(ihc.generate_init_hash).to eq(
+      rom: {
+        'abc' => {
+          type: :teststuff
+        }
+      },
+      remote_ids: {}
+    )
+  end
+
+  it 'generates hashes for each resource with references' do
+    dsl = Tataru::TopDsl.new(Tataru::ResourceTypePool.new)
+    ihc = Tataru::InitHashCompiler.new(dsl)
+
+    rr = Tataru::Representations::ResourceRepresentation.new('file', Tataru::BaseResourceDesc.new, {
+      aaa: Tataru::Representations::LiteralRepresentation.new('meow')
+    })
+    allow(dsl).to receive(:resources) { { 'file1' => rr } }
+
+    allow_any_instance_of(Tataru::Flattener).to receive(:flattened) do
+      {
+        'abc' => {
+          type: :teststuff,
+          references: {
+            thing: 'top_stuff'
+          }
+        }
+      }
+    end
+
+    expect(ihc.generate_init_hash).to eq(
+      rom: {
+        'abc' => {
+          type: :teststuff,
+          references: {
+            thing: 'file1_stuff'
+          }
+        }
+      },
+      remote_ids: {}
+    )
+  end
+end

data/spec/instruction_hash_spec.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require 'tataru'
+
+describe Tataru::InstructionHash do
+  it 'can be made' do
+    im = Tataru::InstructionHash.new(init: {})
+
+    expect(im.instruction_list).to be_empty
+  end
+
+  it 'makes init properly' do
+    im = Tataru::InstructionHash.new(init: {
+      remote_ids: {
+        'thing' => 'abc'
+      }
+    }, instructions: [:init])
+
+    expect(im.instruction_list[0]).to be_a(Tataru::Instructions::InitInstruction)
+    expect(im.instruction_list[0].remote_ids).to eq('thing' => 'abc')
+  end
+
+  it 'adds instructions' do
+    im = Tataru::InstructionHash.new(instructions:[
+      :create
+    ])
+
+    expect(Tataru::Instructions::CreateInstruction).to receive(:new).and_call_original
+
+    expect(im.instruction_list[0]).to be_a(Tataru::Instructions::CreateInstruction)
+  end
+
+  it 'add more instructions' do
+    im = Tataru::InstructionHash.new(instructions:[
+      :create,
+      :delete
+    ])
+
+    expect(Tataru::Instructions::CreateInstruction).to receive(:new).and_call_original
+    expect(Tataru::Instructions::DeleteInstruction).to receive(:new).and_call_original
+
+    expect(im.instruction_list[0]).to be_a(Tataru::Instructions::CreateInstruction)
+    expect(im.instruction_list[1]).to be_a(Tataru::Instructions::DeleteInstruction)
+  end
+
+  it 'adds immediate mode instructions' do
+    im = Tataru::InstructionHash.new(instructions:[
+      { key: 'name' }
+    ])
+
+    expect(Tataru::Instructions::KeyInstruction).to receive(:new).with('name').and_call_original
+
+    expect(im.instruction_list[0]).to be_a(Tataru::Instructions::KeyInstruction)
+  end
+
+  it 'errors on unknown instruction' do
+    im = Tataru::InstructionHash.new(instructions:[
+      :unknown
+    ])
+
+    expect { im.instruction_list[0] }.to raise_error "Unknown instruction 'unknown'"
+  end
+end

data/spec/instruction_spec.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require 'tataru'
+
+describe Tataru::Instruction do
+  it 'can be made' do
+    Tataru::Instruction.new
+  end
+
+  it 'checks parameters' do
+    instr = Class.new(Tataru::Instruction)
+    instr.class_eval do
+      expects :param1
+    end
+
+    mem = Tataru::Memory.new
+    mem.hash[:temp] = {}
+
+    expect { instr.new.execute(mem) }.to raise_error 'required param param1 not found'
+  end
+
+  it 'allows execution to occur if param exists' do
+    instr = Class.new(Tataru::Instruction)
+    instr.class_eval do
+      expects :param1
+    end
+
+    mem = Tataru::Memory.new
+    mem.hash[:temp] = { param1: 'hello' }
+
+    instruction = instr.new
+    expect(instruction).to receive(:run)
+
+    instruction.execute(mem)
+  end
+end

data/spec/instructions/call_instruction_spec.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'tataru'
+
+describe Tataru::Instructions::CallInstruction do
+  it 'call an existing label' do
+    mem = Tataru::Memory.new
+    instr = Tataru::Instructions::CallInstruction.new('function')
+
+    mem.hash[:labels] = { 'function' => 10 }
+    instr.memory = mem
+    instr.run
+
+    expect(mem.program_counter).to eq 9
+  end
+
+  it 'sets error if no such label' do
+    mem = Tataru::Memory.new
+    mem.hash[:labels] = { }
+    instr = Tataru::Instructions::CallInstruction.new('function')
+
+    instr.memory = mem
+    instr.run
+
+    expect(mem.program_counter).to eq 0
+    expect(mem.error).to eq 'Label not found'
+  end
+end

data/spec/instructions/check_create_instruction_spec.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require 'tataru'
+
+describe Tataru::Instructions::CheckCreateInstruction do
+  it 'reverses program counter if not completed' do
+    mem = Tataru::Memory.new
+    instr = Tataru::Instructions::CheckCreateInstruction.new
+
+    expect(mem.program_counter).to eq 0
+
+    mem.hash[:temp] = {
+      resource_name: 'thing',
+      resource_desc: 'Tataru::BaseResourceDesc'
+    }
+    mem.hash[:remote_ids] = { 'thing' => 'hello' }
+    instr.memory = mem
+
+    allow_any_instance_of(Tataru::BaseResource).to receive(:create_complete?) { false }
+    instr.run
+
+    expect(mem.program_counter).to eq -1
+  end
+
+  it 'sets outputs' do
+    mem = Tataru::Memory.new
+    instr = Tataru::Instructions::CheckCreateInstruction.new
+
+    expect(mem.program_counter).to eq 0
+
+    mem.hash[:temp] = {
+      resource_name: 'thing',
+      resource_desc: 'Tataru::BaseResourceDesc'
+    }
+    mem.hash[:remote_ids] = { 'thing' => 'hello' }
+    mem.hash[:outputs] = {}
+    instr.memory = mem
+
+    allow_any_instance_of(Tataru::BaseResource).to receive(:create_complete?) { true }
+    allow_any_instance_of(Tataru::BaseResource).to receive(:outputs) { { something: 'a'} }
+    allow_any_instance_of(Tataru::BaseResourceDesc).to receive(:output_fields) { [:something] }
+    instr.run
+
+    expect(mem.hash[:outputs]['thing']).to eq(something: 'a')
+    expect(mem.program_counter).to eq 0
+  end
+
+  it 'throws if output is not a hash' do
+    mem = Tataru::Memory.new
+    instr = Tataru::Instructions::CheckCreateInstruction.new
+
+    expect(mem.program_counter).to eq 0
+
+    mem.hash[:temp] = {
+      resource_name: 'thing',
+      resource_desc: 'Tataru::BaseResourceDesc'
+    }
+    mem.hash[:remote_ids] = { 'thing' => 'hello' }
+    mem.hash[:outputs] = {}
+    instr.memory = mem
+
+    allow_any_instance_of(Tataru::BaseResource).to receive(:create_complete?) { true }
+    allow_any_instance_of(Tataru::BaseResource).to receive(:outputs) { 'a2' }
+    allow_any_instance_of(Tataru::BaseResourceDesc).to receive(:output_fields) { [:something] }
+    expect { instr.run }.to raise_error "Output for 'thing' is not a hash"
+  end
+end

data/spec/instructions/check_delete_instruction_spec.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require 'tataru'
+
+describe Tataru::Instructions::CheckDeleteInstruction do
+  it 'reverses program counter if not completed' do
+    mem = Tataru::Memory.new
+    instr = Tataru::Instructions::CheckDeleteInstruction.new
+
+    expect(mem.program_counter).to eq 0
+
+    mem.hash[:temp] = {
+      resource_name: 'thing',
+      resource_desc: 'Tataru::BaseResourceDesc'
+    }
+    mem.hash[:remote_ids] = { 'thing' => 'hello' }
+    instr.memory = mem
+
+    allow_any_instance_of(Tataru::BaseResource).to receive(:delete_complete?) { false }
+    instr.run
+
+    expect(mem.program_counter).to eq -1
+  end
+
+  it 'sets deleted' do
+    mem = Tataru::Memory.new
+    instr = Tataru::Instructions::CheckDeleteInstruction.new
+
+    expect(mem.program_counter).to eq 0
+
+    mem.hash[:temp] = {
+      resource_name: 'thing',
+      resource_desc: 'Tataru::BaseResourceDesc'
+    }
+    mem.hash[:remote_ids] = { 'thing' => 'hello' }
+    mem.hash[:deleted] = []
+    instr.memory = mem
+
+    allow_any_instance_of(Tataru::BaseResource).to receive(:delete_complete?) { true }
+    allow_any_instance_of(Tataru::BaseResourceDesc).to receive(:needs_remote_id?) { true }
+    instr.run
+
+    expect(mem.hash[:deleted]).to eq ['thing']
+    expect(mem.hash[:remote_ids]).to eq({})
+    expect(mem.program_counter).to eq 0
+  end
+end

data/spec/instructions/check_update_instruction_spec.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require 'tataru'
+
+describe Tataru::Instructions::CheckUpdateInstruction do
+  it 'reverses program counter if not completed' do
+    mem = Tataru::Memory.new
+    instr = Tataru::Instructions::CheckUpdateInstruction.new
+
+    expect(mem.program_counter).to eq 0
+
+    mem.hash[:temp] = {
+      resource_name: 'thing',
+      resource_desc: 'Tataru::BaseResourceDesc'
+    }
+    mem.hash[:remote_ids] = { 'thing' => 'hello' }
+    instr.memory = mem
+
+    allow_any_instance_of(Tataru::BaseResource).to receive(:update_complete?) { false }
+    instr.run
+
+    expect(mem.program_counter).to eq -1
+  end
+
+  it 'sets outputs' do
+    mem = Tataru::Memory.new
+    instr = Tataru::Instructions::CheckUpdateInstruction.new
+
+    expect(mem.program_counter).to eq 0
+
+    mem.hash[:temp] = {
+      resource_name: 'thing',
+      resource_desc: 'Tataru::BaseResourceDesc'
+    }
+    mem.hash[:remote_ids] = { 'thing' => 'hello' }
+    mem.hash[:outputs] = {}
+    instr.memory = mem
+
+    allow_any_instance_of(Tataru::BaseResource).to receive(:update_complete?) { true }
+    allow_any_instance_of(Tataru::BaseResource).to receive(:outputs) { { something: 'a2'} }
+    allow_any_instance_of(Tataru::BaseResourceDesc).to receive(:output_fields) { [:something] }
+    instr.run
+
+    expect(mem.hash[:outputs]['thing']).to eq(something: 'a2')
+    expect(mem.program_counter).to eq 0
+  end
+
+  it 'throws if output is not a hash' do
+    mem = Tataru::Memory.new
+    instr = Tataru::Instructions::CheckUpdateInstruction.new
+
+    expect(mem.program_counter).to eq 0
+
+    mem.hash[:temp] = {
+      resource_name: 'thing',
+      resource_desc: 'Tataru::BaseResourceDesc'
+    }
+    mem.hash[:remote_ids] = { 'thing' => 'hello' }
+    mem.hash[:outputs] = {}
+    instr.memory = mem
+
+    allow_any_instance_of(Tataru::BaseResource).to receive(:update_complete?) { true }
+    allow_any_instance_of(Tataru::BaseResource).to receive(:outputs) { 'a2' }
+    allow_any_instance_of(Tataru::BaseResourceDesc).to receive(:output_fields) { [:something] }
+    expect { instr.run }.to raise_error "Output for 'thing' is not a hash"
+  end
+end