tataru 0.1.0 → 0.2.0

data/lib/tataru/init_hash_compiler.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Tataru
+  # compiles the inithash
+  class InitHashCompiler
+    def initialize(dsl)
+      @dsl = dsl
+    end
+
+    def resolved_references(resource_name, references)
+      references.map do |field, refname|
+        [field, refname.to_s.sub(/^top/, resource_name)]
+      end.to_h
+    end
+
+    def generate_init_hash
+      rom = {}
+      @dsl.resources.each do |k, v|
+        # Expand all the values used to a big flat hash that
+        # is only one level deep for ease of use, then mark
+        # them for the vm to use
+        flattener = Flattener.new(v)
+        flattener.flattened.each do |key, value|
+          fixed = value.dup
+          if fixed[:references]
+            fixed[:references] = resolved_references(k, fixed[:references])
+          end
+          rom[key.to_s.sub(/^top/, k)] = fixed
+        end
+      end
+      {
+        rom: rom,
+        remote_ids: {}
+      }
+    end
+
+    def result
+      @result ||= generate_init_hash
+    end
+  end
+end

data/lib/tataru/instruction.rb

@@ -1,15 +1,60 @@
 # frozen_string_literal: true
 
 module Tataru
-  # An instruction
+  # a thing to do
   class Instruction
-    attr_reader :action, :id, :state, :requirements
+    class << self
+      attr_accessor :expected_params
 
-    def initialize(action, id, state, requirements)
-      @action = action
-      @id = id
-      @state = state
-      @requirements = requirements
+      def expects(symbol)
+        @expected_params ||= []
+        @expected_params << symbol
+
+        define_method symbol do
+          return nil if @memory&.hash.nil?
+
+          memory.hash[:temp][symbol]
+        end
+      end
+    end
+
+    attr_accessor :memory
+
+    def execute(memory)
+      @memory = memory
+      self.class.expected_params&.each do |symbol|
+        unless memory.hash[:temp].key? symbol
+          raise "required param #{symbol} not found"
+        end
+      end
+
+      run
     end
+
+    def run; end
   end
 end
+
+require 'tataru/instructions/immediate_mode_instruction'
+require 'tataru/instructions/resource_instruction'
+require 'tataru/instructions/check_instruction'
+require 'tataru/instructions/check_delete_instruction'
+require 'tataru/instructions/mark_deletable_instruction'
+require 'tataru/instructions/clear_instruction'
+require 'tataru/instructions/goto_if_instruction'
+require 'tataru/instructions/key_instruction'
+require 'tataru/instructions/value_rom_instruction'
+require 'tataru/instructions/value_update_instruction'
+require 'tataru/instructions/compare_instruction'
+require 'tataru/instructions/delete_instruction'
+require 'tataru/instructions/update_instruction'
+require 'tataru/instructions/create_instruction'
+require 'tataru/instructions/end_instruction'
+require 'tataru/instructions/check_create_instruction'
+require 'tataru/instructions/read_instruction'
+require 'tataru/instructions/check_update_instruction'
+require 'tataru/instructions/rescmp_instruction'
+require 'tataru/instructions/call_instruction'
+require 'tataru/instructions/value_instruction'
+require 'tataru/instructions/return_instruction'
+require 'tataru/instructions/init_instruction'

data/lib/tataru/instruction_hash.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Tataru
+  # representation of a set of instructions
+  class InstructionHash
+    def initialize(thehash)
+      @thehash = thehash
+    end
+
+    def instruction_list
+      @instruction_list ||= instructions
+    end
+
+    def to_h
+      @thehash
+    end
+
+    def instructions
+      return [] unless @thehash[:instructions]
+
+      @thehash[:instructions].map do |action|
+        if action == :init
+          init_instruction
+        elsif action.is_a? Hash
+          # immediate mode instruction
+          instruction_for(action.keys[0]).new(action.values[0])
+        else
+          instruction_for(action).new
+        end
+      end.to_a
+    end
+
+    def instruction_for(action)
+      instr_const = "#{action}_instruction".camelize
+      unless Tataru::Instructions.const_defined? instr_const
+        raise "Unknown instruction '#{action}'"
+      end
+
+      Tataru::Instructions.const_get(instr_const)
+    end
+
+    def init_instruction
+      init = Tataru::Instructions::InitInstruction.new
+
+      inithash = @thehash[:init]
+      if inithash
+        %i[remote_ids outputs deleted rom labels].each do |member|
+          init.send(:"#{member}=", inithash[member]) if inithash.key? member
+        end
+      end
+      init
+    end
+  end
+end

data/lib/tataru/instructions/call_instruction.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Tataru
+  module Instructions
+    # pushes the callstack and branches
+    class CallInstruction < ImmediateModeInstruction
+      def run
+        labels = memory.hash[:labels]
+        unless labels.key? @param
+          memory.error = 'Label not found'
+          return
+        end
+
+        memory.call_stack.push(memory.program_counter)
+        memory.program_counter = labels[@param] - 1
+      end
+    end
+  end
+end

data/lib/tataru/instructions/check_create_instruction.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Tataru
+  module Instructions
+    # instruction to check create
+    class CheckCreateInstruction < CheckInstruction
+      def initialize
+        super :create
+      end
+
+      def after_complete
+        memory.hash[:outputs][resource_name] = outputs
+      end
+
+      def outputs
+        return {} unless desc.output_fields.count
+
+        resource_class = desc.resource_class
+        resource = resource_class.new(memory.hash[:remote_ids][resource_name])
+        o = resource.outputs
+        raise "Output for '#{resource_name}' is not a hash" unless o.is_a? Hash
+
+        resource.outputs
+      end
+    end
+  end
+end

data/lib/tataru/instructions/check_delete_instruction.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Tataru
+  module Instructions
+    # check that delete is completed
+    class CheckDeleteInstruction < CheckInstruction
+      def initialize
+        super :delete
+      end
+
+      def after_complete
+        memory.hash[:deleted] << resource_name
+
+        return unless desc.needs_remote_id?
+
+        memory.hash[:remote_ids].delete(resource_name)
+      end
+    end
+  end
+end

data/lib/tataru/instructions/check_instruction.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Tataru
+  module Instructions
+    # General checking class
+    class CheckInstruction < ResourceInstruction
+      def initialize(check_type)
+        @check_type = check_type
+      end
+
+      def run
+        resource_class = desc.resource_class
+        resource = resource_class.new(memory.hash[:remote_ids][resource_name])
+
+        if resource.send(:"#{@check_type}_complete?")
+          after_complete
+        else
+          # repeat this instruction until its done
+          memory.program_counter -= 1
+        end
+      end
+
+      def after_complete(_memory); end
+    end
+  end
+end

data/lib/tataru/instructions/check_update_instruction.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Tataru
+  module Instructions
+    # check that update is completed
+    class CheckUpdateInstruction < CheckInstruction
+      def initialize
+        super :update
+      end
+
+      def after_complete
+        memory.hash[:outputs][resource_name] = outputs
+      end
+
+      def outputs
+        return {} unless desc.output_fields.count
+
+        resource_class = desc.resource_class
+        resource = resource_class.new(memory.hash[:remote_ids][resource_name])
+        o = resource.outputs
+        raise "Output for '#{resource_name}' is not a hash" unless o.is_a? Hash
+
+        resource.outputs
+      end
+    end
+  end
+end

data/lib/tataru/instructions/clear_instruction.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Tataru
+  module Instructions
+    # clears temp memory
+    class ClearInstruction < Instruction
+      def run
+        memory.hash[:temp] = {}
+      end
+    end
+  end
+end

data/lib/tataru/instructions/compare_instruction.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Tataru
+  module Instructions
+    # compares whats in temp result to param
+    class CompareInstruction < ImmediateModeInstruction
+      def run
+        memory.hash[:temp][:result] = if memory.hash[:temp][:result] == @param
+                                        1
+                                      else
+                                        0
+                                      end
+      end
+    end
+  end
+end

data/lib/tataru/instructions/create_instruction.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Tataru
+  module Instructions
+    # instruction to create
+    class CreateInstruction < ResourceInstruction
+      expects :properties
+
+      def run
+        resource_class = desc.resource_class
+        resource = resource_class.new(nil)
+        resource.create(properties)
+
+        return unless desc.needs_remote_id?
+
+        memory.hash[:remote_ids][resource_name] = resource.remote_id
+      end
+    end
+  end
+end

data/lib/tataru/instructions/delete_instruction.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Tataru
+  module Instructions
+    # instruction to delete
+    class DeleteInstruction < ResourceInstruction
+      def run
+        resource_class = desc.resource_class
+        resource = resource_class.new(memory.hash[:remote_ids][resource_name])
+        resource.delete
+      end
+    end
+  end
+end

data/lib/tataru/instructions/end_instruction.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Tataru
+  module Instructions
+    # ends the program
+    class EndInstruction < Instruction
+      def run
+        memory.end = true
+      end
+    end
+  end
+end

data/lib/tataru/instructions/goto_if_instruction.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Tataru
+  module Instructions
+    # goto if temp result is non zero
+    class GotoIfInstruction < ImmediateModeInstruction
+      def run
+        return if memory.hash[:temp][:result].zero?
+
+        memory.program_counter = if @param.is_a? Integer
+                                   @param - 1
+                                 else
+                                   label_branch!
+                                 end
+      end
+
+      def label_branch!
+        unless memory.hash[:labels]&.key?(@param)
+          raise "Label '#{@param}' not found"
+        end
+
+        memory.hash[:labels][@param] - 1
+      end
+    end
+  end
+end

data/lib/tataru/instructions/immediate_mode_instruction.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Tataru
+  module Instructions
+    # instruction that takes a parameter
+    class ImmediateModeInstruction < Instruction
+      def initialize(param)
+        @param = param
+      end
+    end
+  end
+end

data/lib/tataru/instructions/init_instruction.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Tataru
+  module Instructions
+    # instruction to initialize the memory
+    class InitInstruction < Instruction
+      attr_accessor :remote_ids, :outputs, :rom, :labels, :deleted
+
+      def initialize
+        @remote_ids = {}
+        @outputs = {}
+        @rom = {}
+        @labels = {}
+        @deleted = []
+      end
+
+      def run
+        memory.hash[:remote_ids] = @remote_ids
+        memory.hash[:outputs] = @outputs
+        memory.hash[:labels] = @labels
+        memory.hash[:rom] = @rom.freeze
+        memory.hash[:deleted] = @deleted
+        memory.hash[:update_action] = {}
+      end
+    end
+  end
+end

data/lib/tataru/instructions/key_instruction.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Tataru
+  module Instructions
+    # sets a key
+    class KeyInstruction < ImmediateModeInstruction
+      def run
+        memory.hash[:temp][:_key] = @param
+      end
+    end
+  end
+end