tataru 0.1.0 → 0.2.0

data/lib/tataru/instructions/mark_deletable_instruction.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Tataru
+  module Instructions
+    # puts remote id up for deletion
+    class MarkDeletableInstruction < ResourceInstruction
+      def run
+        remote_id = memory.hash[:remote_ids].delete(resource_name)
+        memory.hash[:remote_ids]["_deletable_#{resource_name}"] = remote_id
+      end
+    end
+  end
+end

data/lib/tataru/instructions/read_instruction.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Tataru
+  module Instructions
+    # read properties of resource
+    class ReadInstruction < ResourceInstruction
+      def run
+        results = resource.read(fields)
+        memory.hash[:temp][resource_name] = {}
+        fields.each do |k|
+          memory.hash[:temp][resource_name][k] = results[k]
+        end
+      end
+
+      def resource_class
+        desc.resource_class
+      end
+
+      def resource
+        resource_class.new(memory.hash[:remote_ids][resource_name])
+      end
+
+      def fields
+        @fields ||= desc.immutable_fields + desc.mutable_fields
+      end
+    end
+  end
+end

data/lib/tataru/instructions/rescmp_instruction.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Tataru
+  module Instructions
+    # compares resource in temp and resource in top
+    class RescmpInstruction < ResourceInstruction
+      include RomReader
+
+      def run
+        raise 'Not found' unless rom.key? resource_name
+
+        update!
+      end
+
+      def update!
+        current = memory.hash[:temp][resource_name]
+        desired = resolve(rom[resource_name])
+
+        memory.hash[:update_action][resource_name] = compare(current, desired)
+      end
+
+      def compare(current, desired)
+        result = :no_change
+        desc.mutable_fields.each do |field|
+          result = :modify if current[field] != desired[field]
+        end
+        desc.immutable_fields.each do |field|
+          result = :recreate if current[field] != desired[field]
+        end
+        result
+      end
+    end
+  end
+end

data/lib/tataru/instructions/resource_instruction.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Tataru
+  module Instructions
+    # instructions that deal with resources
+    class ResourceInstruction < Instruction
+      expects :resource_name
+      expects :resource_desc
+
+      def desc
+        Kernel.const_get(resource_desc).new
+      end
+    end
+  end
+end

data/lib/tataru/instructions/return_instruction.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Tataru
+  module Instructions
+    # pops the callstack and goes back
+    class ReturnInstruction < Instruction
+      def run
+        if memory.call_stack.count.zero?
+          return memory.error = 'At bottom of stack'
+        end
+
+        memory.program_counter = memory.call_stack.pop
+      end
+    end
+  end
+end

data/lib/tataru/instructions/update_instruction.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Tataru
+  module Instructions
+    # update a resource
+    class UpdateInstruction < ResourceInstruction
+      expects :properties
+
+      def run
+        resource_class = desc.resource_class
+        resource = resource_class.new(memory.hash[:remote_ids][resource_name])
+        resource.update(properties)
+      end
+    end
+  end
+end

data/lib/tataru/instructions/value_instruction.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Tataru
+  module Instructions
+    # sets a hash entry based on whatever key was set
+    class ValueInstruction < ImmediateModeInstruction
+      def run
+        return memory.error = 'No key set' unless memory.hash[:temp].key? :_key
+
+        key = memory.hash[:temp].delete :_key
+        memory.hash[:temp][key] = @param
+      end
+    end
+  end
+end

data/lib/tataru/instructions/value_rom_instruction.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Tataru
+  module Instructions
+    # sets a hash entry and resolves from rom what was set
+    class ValueRomInstruction < ImmediateModeInstruction
+      include RomReader
+
+      def run
+        return memory.error = 'No key set' unless memory.hash[:temp].key? :_key
+
+        key = memory.hash[:temp].delete :_key
+        memory.hash[:temp][key] = resolve(rom_object)
+      end
+
+      def rom_object
+        raise 'Not found' unless rom.key? @param
+
+        rom[@param]
+      end
+    end
+  end
+end

data/lib/tataru/instructions/value_update_instruction.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Tataru
+  module Instructions
+    # sets temp result
+    class ValueUpdateInstruction < ImmediateModeInstruction
+      def run
+        unless memory.hash[:update_action].key? @param
+          raise "No value set for '#{@param}'"
+        end
+
+        memory.hash[:temp] = {
+          result: memory.hash[:update_action][@param]
+        }
+      end
+    end
+  end
+end

data/lib/tataru/memory.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Tataru
+  # memory that can be manipulated by instructions
+  class Memory
+    attr_accessor :program_counter, :hash, :call_stack, :error, :end
+
+    def initialize
+      @program_counter = 0
+      @hash = { temp: {} }
+      @error = nil
+      @call_stack = []
+      @end = false
+    end
+  end
+end

data/lib/tataru/quest.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Tataru
+  # tataru
+  class Quest
+    attr_reader :dsl
+
+    def initialize(pool, current_state = {})
+      @pool = pool
+      @current_state = current_state
+      @dsl = TopDsl.new(pool)
+    end
+
+    def construct(&block)
+      @dsl.instance_eval(&block)
+    end
+
+    def extant_resources
+      @current_state.map do |resname, info|
+        [resname, info[:desc]]
+      end.to_h
+    end
+
+    def remote_ids
+      @current_state.map do |resname, info|
+        [resname, info[:name]]
+      end.to_h
+    end
+
+    def extant_dependencies
+      @current_state.map do |resname, info|
+        [resname, info[:dependencies]]
+      end.to_h
+    end
+
+    def instr_hash
+      c = Compiler.new(@dsl, extant_resources, extant_dependencies)
+      result = c.instr_hash
+      result[:init][:remote_ids] = remote_ids
+      result
+    end
+  end
+end

data/lib/tataru/representation.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Tataru
+  # base representation
+  class Representation
+    attr_reader :value
+
+    def initialize(value)
+      @value = value
+    end
+
+    def dependencies
+      []
+    end
+  end
+end
+
+require 'tataru/representations/hash_representation'
+require 'tataru/representations/array_representation'
+require 'tataru/representations/literal_representation'
+require 'tataru/representations/output_representation'
+require 'tataru/representations/resource_representation'

data/lib/tataru/representations/array_representation.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Tataru
+  module Representations
+    # representing arrays
+    class ArrayRepresentation < Representation
+      def initialize(value)
+        @value = value.map do |thing|
+          Resolver.new(thing).representation
+        end.to_a
+      end
+
+      def dependencies
+        @dependencies ||= @value.flat_map(&:dependencies)
+      end
+    end
+  end
+end

data/lib/tataru/representations/hash_representation.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Tataru
+  module Representations
+    # representing hashes
+    class HashRepresentation < Representation
+      def initialize(value)
+        @value = value.map do |key, thing|
+          [key, Resolver.new(thing).representation]
+        end.to_h
+      end
+
+      def dependencies
+        @dependencies ||= @value.flat_map do |_key, rep|
+          rep.dependencies
+        end
+      end
+    end
+  end
+end

data/lib/tataru/representations/literal_representation.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Tataru
+  module Representations
+    # representing simple values
+    class LiteralRepresentation < Representation
+    end
+  end
+end

data/lib/tataru/representations/output_representation.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Tataru
+  module Representations
+    # internal representation of output
+    class OutputRepresentation < Representation
+      attr_reader :resource_name, :output_field_name
+
+      def initialize(resource_name, output_field_name)
+        @resource_name = resource_name
+        @output_field_name = output_field_name
+      end
+
+      def dependencies
+        [@resource_name]
+      end
+    end
+  end
+end

data/lib/tataru/representations/resource_representation.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Tataru
+  module Representations
+    # internal representation of resources
+    class ResourceRepresentation < Representation
+      attr_reader :name, :properties, :desc
+
+      def initialize(name, desc, properties)
+        @name = name
+        @properties = properties
+        @desc = desc
+        check_late_deletability!
+      end
+
+      def check_late_deletability!
+        return unless @desc.delete_at_end? && !@desc.needs_remote_id?
+
+        raise 'must need remote id if deletes at end'
+      end
+
+      def check_required_fields!
+        @desc.required_fields.each do |field|
+          next if @properties.key? field
+
+          raise "Required field '#{field}' not provided in '#{@name}'"
+        end
+      end
+
+      def respond_to_missing?(name, *_args)
+        true if @desc.output_fields.include? name
+      end
+
+      def remote_id
+        OutputRepresentation.new(@name, :remote_id)
+      end
+
+      def method_missing(name, *args, &block)
+        return super unless @desc.output_fields.include? name
+
+        OutputRepresentation.new(@name, name)
+      end
+
+      def dependencies
+        [@name]
+      end
+    end
+  end
+end

data/lib/tataru/resolver.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Tataru
+  # resolver for data
+  class Resolver
+    def initialize(expression)
+      @expression = expression
+    end
+
+    def representation
+      @representation ||= generate_representation
+    end
+
+    def dependencies
+      representation.dependencies
+    end
+
+    private
+
+    def generate_representation
+      case @expression
+      when String
+        Representations::LiteralRepresentation.new(@expression)
+      when Numeric
+        Representations::LiteralRepresentation.new(@expression)
+      when Array
+        Representations::ArrayRepresentation.new(@expression)
+      when Hash
+        Representations::HashRepresentation.new(@expression)
+      when Representations::ResourceRepresentation
+        @expression
+      when Representations::OutputRepresentation
+        @expression
+      else
+        raise "invalid value: #{@expression.inspect}"
+      end
+    end
+  end
+end

data/lib/tataru/resource_dsl.rb

@@ -1,86 +1,36 @@
 # frozen_string_literal: true
 
 module Tataru
-  module DoLater
-    # delayed expression
-    class Expression
-      def requested_resources
-        raise 'Abstract class'
-      end
-    end
-
-    # placeholder for extern resource
-    class ExternResourcePlaceholder < Expression
-      def initialize(name)
-        @name = name
-      end
-
-      def respond_to_missing?
-        true
-      end
-
-      def method_missing(name, *_args)
-        super if name.nil?
-
-        MemberCallPlaceholder.new(self, name)
-      end
-
-      def requested_resources
-        [@name]
-      end
-    end
+  # human representation of resources
+  class ResourceDsl
+    REPCLASS = Tataru::Representations::ResourceRepresentation
 
-    # placeholder for member call
-    class MemberCallPlaceholder < ExternResourcePlaceholder
-      def initialize(expr, member)
-        @expr = expr
-        @member = member
-      end
-
-      def requested_resources
-        @expr.requested_resources
-      end
+    def initialize(name, desc)
+      @properties = {}
+      @desc = desc
+      @fields = Set.new(@desc.mutable_fields + @desc.immutable_fields)
+      @name = name
+      @dependencies = Set.new
     end
-  end
 
-  # Resource DSL
-  class ResourceDSL
-    attr_reader :fields, :extern_refs
-
-    def initialize(resource_inst)
-      @resource_inst = resource_inst
-      @fields = {}
-      @extern_refs = {}
-    end
-
-    def respond_to_missing?
-      true
+    def respond_to_missing?(name, *_args)
+      true if @fields.include? name
     end
 
     def method_missing(name, *args, &block)
-      if @resource_inst.respond_to?("#{name}_change_action")
-        @fields[name] = args[0]
-      elsif name.to_s.start_with?(/[a-z]/)
-        @extern_refs[name] ||= DoLater::ExternResourcePlaceholder.new(name)
-      else
-        super
-      end
-    end
+      return super unless @fields.include? name
 
-    def errors
-      (@resource_inst.states - @fields.keys).map do |x|
-        { missing_state: x }
-      end
+      resolver = Resolver.new(args[0])
+      @dependencies += resolver.dependencies
+      @properties[name] = if resolver.representation.is_a? REPCLASS
+                            resolver.representation.remote_id
+                          else
+                            resolver.representation
+                          end
     end
 
-    def dependencies
-      deps = []
-      @fields.each do |_name, info|
-        next unless info.is_a? DoLater::Expression
-
-        deps += info.requested_resources
-      end
-      deps.map(&:to_s).uniq
+    def representation
+      REPCLASS.new(@name, @desc, @properties)
     end
   end
 end