tataru 0.1.0 → 0.2.0

data/lib/tataru/resource_type_pool.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Tataru
+  # class resource type pool
+  class ResourceTypePool
+    def initialize
+      @pool = {}
+    end
+
+    def add_resource_desc(symbol, classconstant)
+      @pool[symbol] = classconstant
+    end
+
+    def resource_desc_for(symbol)
+      @pool[symbol]
+    end
+
+    def resource_desc_exist?(symbol)
+      @pool.key? symbol
+    end
+  end
+end

data/lib/tataru/rom_reader.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Tataru
+  # Reads Rom values
+  module RomReader
+    def rom
+      memory.hash[:rom]
+    end
+
+    def resolve(object)
+      case object[:type]
+      when :literal
+        object[:value]
+      when :hash
+        resolve_hash(object)
+      when :array
+        resolve_array(object)
+      when :output
+        resolve_output(object)
+      end
+    end
+
+    def resolve_array(object)
+      result = []
+      object[:references].each do |k, v|
+        result[k] = resolve(rom[v])
+      end
+      result
+    end
+
+    def resolve_hash(object)
+      result = {}
+      object[:references].each do |k, v|
+        result[k] = resolve(rom[v])
+      end
+      result
+    end
+
+    def resolve_output(object)
+      if object[:output] == :remote_id
+        memory.hash[:remote_ids][object[:resource]]
+      else
+        memory.hash[:outputs][object[:resource]][object[:output]]
+      end
+    end
+  end
+end

data/lib/tataru/runner.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Tataru
+  # thing that runs a quest
+  class Runner
+    attr_reader :memory, :oplog
+
+    def initialize(instruction_list)
+      @memory = Memory.new
+      @instruction_list = instruction_list
+      @oplog = []
+    end
+
+    def ended?
+      @memory.program_counter >= @instruction_list.length ||
+        !@memory.error.nil? ||
+        @memory.end
+    end
+
+    def log_operation(instr)
+      return unless instr.is_a? Instructions::ResourceInstruction
+
+      oplog << {
+        operation: instr.class.name.underscore
+                        .sub(%r{^tataru/instructions/}, '')
+                        .sub(/_instruction$/, '').upcase.to_s,
+        resource: (memory.hash[:temp][:resource_name]).to_s
+      }
+    end
+
+    def run_next
+      return if ended?
+
+      instr = @instruction_list[@memory.program_counter]
+
+      log_operation(instr)
+
+      instr.execute(@memory)
+      @memory.program_counter += 1
+    rescue RuntimeError => e
+      @memory.error = e
+    rescue StandardError => e
+      @memory.error = e
+    end
+
+    def current_state; end
+  end
+end

data/lib/tataru/sub_planner.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Tataru
+  # returns subroutines required based on the resource
+  class SubPlanner
+    def initialize(rrep, action)
+      @rrep = rrep
+      @action = action
+    end
+
+    def name
+      @rrep.name
+    end
+
+    def compile(*args)
+      SubroutineCompiler.new(@rrep, *args)
+    end
+
+    def extra_subroutines
+      return {} unless @action == :update
+
+      {
+        "#{name}_modify" => compile(:modify),
+        "#{name}_modify_check" => compile(:modify_check),
+        "#{name}_recreate" => compile(:recreate),
+        "#{name}_recreate_check" => compile(:recreate_check),
+        "#{name}_recreate_commit" => compile(:recreate_commit),
+        "#{name}_recreate_finish" => compile(:recreate_finish)
+      }
+    end
+
+    def subroutines
+      {
+        "#{name}_start" => compile(:"#{@action}"),
+        "#{name}_check" => compile(:"check_#{@action}"),
+        "#{name}_commit" => compile(:"commit_#{@action}"),
+        "#{name}_finish" => compile(:"finish_#{@action}")
+      }.merge(extra_subroutines)
+    end
+  end
+end

data/lib/tataru/subroutine_compiler.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Tataru
+  # a subroutine for handling a resource
+  class SubroutineCompiler
+    include CreateSubroutines
+    include UpdateSubroutines
+    include DeleteSubroutines
+
+    def initialize(resource_representation, action)
+      @rrep = resource_representation
+      @action = action
+    end
+
+    def desc
+      @rrep.desc
+    end
+
+    def label
+      "#{@action}_#{@rrep.name}"
+    end
+
+    def base_action
+      @action.to_s.split('_')[1].to_s
+    end
+
+    def body_instructions
+      [
+        :clear,
+        *inner_instructions,
+        :return
+      ]
+    end
+
+    def load_resource_instructions
+      [
+        { key: :resource_name },
+        { value: @rrep.name },
+        { key: :resource_desc },
+        { value: @rrep.desc.class.name }
+      ]
+    end
+
+    def inner_instructions
+      send :"#{@action}_instructions"
+    end
+
+    def call_instruction
+      { call: label }
+    end
+  end
+end

data/lib/tataru/top_dsl.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Tataru
+  # human representation of resources
+  class TopDsl
+    attr_reader :resources
+
+    def initialize(pool)
+      @resources = {}
+      @pool = pool
+    end
+
+    def resource(symbol, name, &block)
+      unless @pool.resource_desc_exist?(symbol)
+        raise "no such resource: #{symbol}"
+      end
+      raise "already defined: #{name}" if @resources.key? name
+
+      resource = ResourceDsl.new(name, @pool.resource_desc_for(symbol).new)
+      resource.instance_eval(&block) if block
+
+      @resources[name] = resource.representation
+    end
+
+    def dep_graph
+      @resources.map do |name, resource_representation|
+        deps = Set.new
+        resource_representation.properties.each do |_key, value|
+          deps += value.dependencies
+        end
+        [name, deps.to_a]
+      end.to_h
+    end
+  end
+end

data/lib/tataru/update_subroutines.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module Tataru
+  # update subroutines
+  module UpdateSubroutines
+    def update_instructions
+      [
+        *load_resource_instructions,
+        :read,
+        *load_resource_instructions,
+        :rescmp,
+        { value_update: @rrep.name },
+        { compare: :recreate },
+        { goto_if: "recreate_#{@rrep.name}" },
+        { value_update: @rrep.name },
+        { compare: :modify },
+        { goto_if: "modify_#{@rrep.name}" }
+      ]
+    end
+
+    def check_update_instructions
+      [
+        { value_update: @rrep.name },
+        { compare: :recreate },
+        { goto_if: "recreate_check_#{@rrep.name}" },
+        { value_update: @rrep.name },
+        { compare: :modify },
+        { goto_if: "modify_check_#{@rrep.name}" }
+      ]
+    end
+
+    def commit_update_instructions
+      [
+        { value_update: @rrep.name },
+        { compare: :recreate },
+        { goto_if: "recreate_commit_#{@rrep.name}" }
+      ]
+    end
+
+    def finish_update_instructions
+      [
+        { value_update: @rrep.name },
+        { compare: :recreate },
+        { goto_if: "recreate_finish_#{@rrep.name}" }
+      ]
+    end
+
+    def modify_instructions
+      [
+        *load_resource_instructions,
+        { key: :properties },
+        { value_rom: @rrep.name },
+        :update
+      ]
+    end
+
+    def modify_check_instructions
+      [
+        *load_resource_instructions,
+        :check_update
+      ]
+    end
+
+    def recreate_instructions
+      deletion_routine = [
+        *load_resource_instructions,
+        :mark_deletable
+      ]
+      unless desc.delete_at_end?
+        deletion_routine = [
+          *delete_instructions,
+          *check_delete_instructions
+        ]
+      end
+      [
+        *deletion_routine,
+        *create_instructions
+      ]
+    end
+
+    def recreate_check_instructions
+      [
+        *check_create_instructions
+      ]
+    end
+
+    def recreate_commit_instructions
+      return [] unless desc.delete_at_end?
+
+      [
+        { key: :resource_name },
+        { value: "_deletable_#{@rrep.name}" },
+        { key: :resource_desc },
+        { value: @rrep.desc.class.name },
+        :delete
+      ]
+    end
+
+    def recreate_finish_instructions
+      return [] unless desc.delete_at_end?
+
+      [
+        { key: :resource_name },
+        { value: "_deletable_#{@rrep.name}" },
+        { key: :resource_desc },
+        { value: @rrep.desc.class.name },
+        :check_delete
+      ]
+    end
+  end
+end

data/lib/tataru/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Tataru
-  VERSION = '0.1.0'
+  VERSION = '0.2.0'
 end

data/spec/compiler_spec.rb

@@ -0,0 +1,181 @@
+# frozen_string_literal: true
+
+require 'tataru'
+
+describe Tataru::Compiler do
+  it 'outputs the correct default format' do
+    dsl = Tataru::TopDsl.new(Tataru::ResourceTypePool.new)
+    compiler = Tataru::Compiler.new(dsl)
+    expect(compiler.instr_hash).to eq(
+      init: {
+        labels: {},
+        remote_ids: {},
+        rom: {}
+      },
+      instructions: [:init, :end]
+    )
+  end
+
+  it 'outputs top instructions and subroutine instructions' do
+    dsl = Tataru::TopDsl.new(Tataru::ResourceTypePool.new)
+    compiler = Tataru::Compiler.new(dsl)
+
+    allow(compiler).to receive(:top_instructions) { [:meow] }
+    allow(compiler).to receive(:subroutine_instructions) { [:woof] }
+
+    expect(compiler.instr_hash).to eq(
+      init: {
+        labels: {},
+        remote_ids: {},
+        rom: {}
+      },
+      instructions: [:meow, :woof]
+    )
+  end
+
+  it 'wraps instructions with init and end' do
+    dsl = Tataru::TopDsl.new(Tataru::ResourceTypePool.new)
+    compiler = Tataru::Compiler.new(dsl)
+
+    allow(compiler).to receive(:generate_top_instructions) { [:meow] }
+    
+    expect(compiler.top_instructions).to eq [:init, :meow, :end]
+  end
+
+  it 'makes all the subroutine instructions mixed in' do
+    dsl = Tataru::TopDsl.new(Tataru::ResourceTypePool.new)
+    compiler = Tataru::Compiler.new(dsl)
+
+    a = double('SubroutineCompiler')
+    b = double('SubroutineCompiler')
+
+    allow(a).to receive(:body_instructions) { [:meow, :purr] }
+    allow(b).to receive(:body_instructions) { [:pant, :woof] }
+    allow(compiler).to receive(:subroutines) { {a: a, b: b} }
+
+    expect(compiler.subroutine_instructions).to eq [:meow, :purr, :pant, :woof]
+  end
+
+  it 'assigns the correct numbers to labels' do
+    dsl = Tataru::TopDsl.new(Tataru::ResourceTypePool.new)
+    compiler = Tataru::Compiler.new(dsl)
+
+    a = double('SubroutineCompiler')
+    b = double('SubroutineCompiler')
+
+    allow(a).to receive(:body_instructions) { [:meow, :purr, :drink_milk] }
+    allow(b).to receive(:body_instructions) { [:pant, :woof] }
+
+    allow(a).to receive(:label) { :cat }
+    allow(b).to receive(:label) { :dog }
+
+    allow(compiler).to receive(:subroutines) { {a: a, b: b} }
+
+    expect(compiler.generate_labels).to eq(cat: 2, dog: 5)
+  end
+
+  it 'generates the right subroutines' do
+    dsl = Tataru::TopDsl.new(Tataru::ResourceTypePool.new)
+    compiler = Tataru::Compiler.new(dsl)
+
+    dummy = double('SubroutineCompiler')
+    allow(dummy).to receive(:call_instruction)
+
+    dummy_subroutine_hash = double('Hash')
+    allow(compiler).to receive(:subroutines) { dummy_subroutine_hash }
+
+    allow(dsl).to receive(:dep_graph) { { a: [:b], c: [:b], b: [] } }
+
+    expect(dummy_subroutine_hash).to receive(:[]).with('b_start') { dummy }
+    expect(dummy_subroutine_hash).to receive(:[]).with('b_check') { dummy }
+    expect(dummy_subroutine_hash).to receive(:[]).with('b_commit') { dummy }
+    expect(dummy_subroutine_hash).to receive(:[]).with('b_finish') { dummy }
+
+    expect(dummy_subroutine_hash).to receive(:[]).with('a_start') { dummy }
+    expect(dummy_subroutine_hash).to receive(:[]).with('a_check') { dummy }
+    expect(dummy_subroutine_hash).to receive(:[]).with('a_commit') { dummy }
+    expect(dummy_subroutine_hash).to receive(:[]).with('a_finish') { dummy }
+
+    expect(dummy_subroutine_hash).to receive(:[]).with('c_start') { dummy }
+    expect(dummy_subroutine_hash).to receive(:[]).with('c_check') { dummy }
+    expect(dummy_subroutine_hash).to receive(:[]).with('c_commit') { dummy }
+    expect(dummy_subroutine_hash).to receive(:[]).with('c_finish') { dummy }
+
+    compiler.generate_top_instructions
+  end
+
+  it 'generates create instructions by default' do
+    dsl = Tataru::TopDsl.new(Tataru::ResourceTypePool.new)
+    compiler = Tataru::Compiler.new(dsl)
+
+    cat = Tataru::Representations::ResourceRepresentation.new('ccat', Tataru::BaseResourceDesc.new, {})
+    dog = Tataru::Representations::ResourceRepresentation.new('ddog', Tataru::BaseResourceDesc.new, {})
+    allow(dsl).to receive(:resources) do
+      {
+        'cat' => cat,
+        'dog' => dog
+      }
+    end
+
+    expect(Tataru::SubroutineCompiler).to receive(:new).with(cat, :create)
+    expect(Tataru::SubroutineCompiler).to receive(:new).with(cat, :check_create)
+
+    expect(Tataru::SubroutineCompiler).to receive(:new).with(cat, :commit_create)
+    expect(Tataru::SubroutineCompiler).to receive(:new).with(cat, :finish_create)
+
+    expect(Tataru::SubroutineCompiler).to receive(:new).with(dog, :create)
+    expect(Tataru::SubroutineCompiler).to receive(:new).with(dog, :check_create)
+
+    expect(Tataru::SubroutineCompiler).to receive(:new).with(dog, :commit_create)
+    expect(Tataru::SubroutineCompiler).to receive(:new).with(dog, :finish_create)
+
+    expect(compiler.generate_subroutines.keys).to eq [
+      'ccat_start', 'ccat_check', 'ccat_commit', 'ccat_finish',
+      'ddog_start', 'ddog_check', 'ddog_commit', 'ddog_finish'
+    ]
+  end
+
+  it 'generates delete instructions for extant names' do
+    dsl = Tataru::TopDsl.new(Tataru::ResourceTypePool.new)
+    compiler = Tataru::Compiler.new(dsl, { 'thing' => 'BaseResourceDesc' })
+
+    expect(Tataru::SubroutineCompiler).to receive(:new).with(instance_of(Tataru::Representations::ResourceRepresentation), :delete)
+    expect(Tataru::SubroutineCompiler).to receive(:new).with(instance_of(Tataru::Representations::ResourceRepresentation), :check_delete)
+    expect(Tataru::SubroutineCompiler).to receive(:new).with(instance_of(Tataru::Representations::ResourceRepresentation), :commit_delete)
+    expect(Tataru::SubroutineCompiler).to receive(:new).with(instance_of(Tataru::Representations::ResourceRepresentation), :finish_delete)
+
+    expect(compiler.generate_subroutines.keys).to eq [
+      'thing_start', 'thing_check', 'thing_commit', 'thing_finish'
+    ]
+  end
+
+  it 'generates update instructions for extant names that are set' do
+    dsl = Tataru::TopDsl.new(Tataru::ResourceTypePool.new)
+    compiler = Tataru::Compiler.new(dsl, { 'thong' => 'BaseResourceDesc' })
+
+    dog = Tataru::Representations::ResourceRepresentation.new('ddog', Tataru::BaseResourceDesc.new, {})
+    allow(dsl).to receive(:resources) do
+      {
+        'thong' => dog
+      }
+    end
+
+    expect(Tataru::SubroutineCompiler).to receive(:new).with(dog, :update)
+    expect(Tataru::SubroutineCompiler).to receive(:new).with(dog, :check_update)
+    expect(Tataru::SubroutineCompiler).to receive(:new).with(dog, :commit_update)
+    expect(Tataru::SubroutineCompiler).to receive(:new).with(dog, :finish_update)
+    expect(Tataru::SubroutineCompiler).to receive(:new).with(dog, :modify)
+    expect(Tataru::SubroutineCompiler).to receive(:new).with(dog, :modify_check)
+    expect(Tataru::SubroutineCompiler).to receive(:new).with(dog, :recreate)
+    expect(Tataru::SubroutineCompiler).to receive(:new).with(dog, :recreate_check)
+    expect(Tataru::SubroutineCompiler).to receive(:new).with(dog, :recreate_commit)
+    expect(Tataru::SubroutineCompiler).to receive(:new).with(dog, :recreate_finish)
+
+    expect(compiler.generate_subroutines.keys).to eq [
+      'ddog_start', 'ddog_check', 'ddog_commit', 'ddog_finish',
+      'ddog_modify', 'ddog_modify_check',
+      'ddog_recreate', 'ddog_recreate_check',
+      'ddog_recreate_commit', 'ddog_recreate_finish'
+    ]
+  end
+end