tataru 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e42d1ffd98cb2d158b53f58b572cba30e0e08cb9da10f65386260bf24156b069
-  data.tar.gz: 2078749626908e57c5bef6759dbba0ff2e244638f4811c36d1cfc97dc841a688
+  metadata.gz: a3fcccc4e7437ee62c60032204c2c0fccb36291e0ffdd240021fb2248e4e8b62
+  data.tar.gz: 0432c564d3338a05984e50cc57ef59085273a935ad32882d48f1ba6611e9a53f
 SHA512:
-  metadata.gz: c9eefcedd70c5328abbae21d9e286d751e819f28b7fb85c64468aa3f978ddabb29f3f40cecf4bf557e9eb0da4ee6e78a8cf402b4e49ed9e145586ac3df52cbee
-  data.tar.gz: c5f88a391a8f67f6ab30afd095fbf438a8ae76dcc08e7febbaba563d733f5209da60bbb6c23e3d9f343e0256c04c329f689f1b0dde156083c0d9c3e348f33553
+  metadata.gz: fcaa6f65aaa656d8933901ba3bc8257b6ef41a78b6ec9b2ffd25efd1e2f283c250349ea079019ba4f34ba92e553af22ba1c17e61a84fddc8cdc9de305c8639f6
+  data.tar.gz: c3d436483365f80eecb90247dfafc149fddfb56ead3376db15ebe4485291aa72aaca5e5bf89ae3a85b24e57835ba81c9575176c55c13d4ce39b2981394b85fae

data/Gemfile

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+gemspec

data/bin/console

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'binrip'
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require 'irb'
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/tataru.rb

@@ -1,15 +1,73 @@
 # frozen_string_literal: true
 
-require 'active_support/inflector'
-require 'bunny/tsort'
-
-require 'tataru/version'
-require 'tataru/resource'
-require 'tataru/state'
-require 'tataru/instruction'
-require 'tataru/execution_step'
-require 'tataru/planner'
-require 'tataru/default_resource_finder'
-require 'tataru/requirements_dsl'
+require 'tataru/rom_reader'
+require 'tataru/base_resource'
+require 'tataru/base_resource_desc'
+require 'tataru/representation'
 require 'tataru/resource_dsl'
-require 'tataru/requirements'
+require 'tataru/resolver'
+require 'tataru/top_dsl'
+require 'tataru/flattener'
+require 'tataru/create_subroutines'
+require 'tataru/delete_subroutines'
+require 'tataru/update_subroutines'
+require 'tataru/subroutine_compiler'
+require 'tataru/init_hash_compiler'
+require 'tataru/sub_planner'
+require 'tataru/compiler'
+require 'tataru/quest'
+require 'tataru/resource_type_pool'
+require 'tataru/instruction_hash'
+require 'tataru/instruction'
+require 'tataru/memory'
+require 'tataru/runner'
+
+module Tataru
+  # Entry class
+  class Taru
+    def initialize(rtp, current_state = {}, &block)
+      @rtp = rtp
+      @current_state = current_state
+      @quest = Tataru::Quest.new(rtp, current_state)
+      @quest.construct(&block)
+      @ih = Tataru::InstructionHash.new(@quest.instr_hash)
+      @runner = Tataru::Runner.new(@ih.instruction_list)
+    end
+
+    def step
+      @runner.run_next
+      !@runner.ended?
+    end
+
+    def oplog
+      @runner.oplog
+    end
+
+    def error
+      @runner.memory.error
+    end
+
+    def state
+      @runner.memory.hash[:remote_ids].map do |k, v|
+        extract_state(k, v)
+      end.to_h
+    end
+
+    def extract_state(key, value)
+      if key.start_with? '_deletable_'
+        original_key = key.sub(/^_deletable_/, '')
+        [key, {
+          name: value,
+          desc: @current_state[original_key][:desc],
+          dependencies: @current_state[original_key][:dependencies]
+        }]
+      else
+        [key, {
+          name: value,
+          desc: @quest.dsl.resources[key].desc.class.name,
+          dependencies: @quest.dsl.dep_graph[key]
+        }]
+      end
+    end
+  end
+end

data/lib/tataru/base_resource.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Tataru
+  # base class of resource
+  class BaseResource
+    attr_reader :remote_id
+
+    def initialize(remote_id)
+      @remote_id = remote_id
+    end
+
+    def create(_name_value_hash)
+      # create the resource
+    end
+
+    def read(_name_array)
+      # read a range of resource fields
+      {}
+    end
+
+    def update(name_value_hash)
+      # update the resource fields
+    end
+
+    def delete
+      # delete the resource
+    end
+
+    def outputs
+      # resource outputs
+      {}
+    end
+
+    def create_complete?
+      # check if creation is complete
+      true
+    end
+
+    def update_complete?
+      # check if update is complete
+      true
+    end
+
+    def delete_complete?
+      # check if delete is complete
+      true
+    end
+  end
+end

data/lib/tataru/base_resource_desc.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Tataru
+  # description of a resource
+  class BaseResourceDesc
+    def resource_class
+      # returns the class of the resource
+      BaseResource
+    end
+
+    def mutable_fields
+      [] # fields that can be passed in to create and update
+    end
+
+    def immutable_fields
+      [] # fields that cannot be passed in to update but can be passed to create
+    end
+
+    def output_fields
+      [] # fields that cannot be passed in to create or update
+    end
+
+    def required_fields
+      [] # mutable or immutable fields that cannot be omitted
+    end
+
+    def needs_remote_id?
+      false # true if resource requires a remote id
+    end
+
+    def delete_at_end?
+      false # if true moves deletes to end of program
+    end
+  end
+end

data/lib/tataru/compiler.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require 'bunny/tsort'
+
+module Tataru
+  # compiler
+  class Compiler
+    def initialize(dsl, extant_resources = {}, extant_dependencies = {})
+      @dsl = dsl
+      @extant = extant_resources
+      @extant_dependencies = extant_dependencies
+    end
+
+    def instr_hash
+      {
+        init: {
+          **InitHashCompiler.new(@dsl).result,
+          labels: labels
+        },
+        instructions: top_instructions + subroutine_instructions
+      }
+    end
+
+    def labels
+      @labels ||= generate_labels
+    end
+
+    def subroutines
+      @subroutines ||= generate_subroutines
+    end
+
+    def top_instructions
+      @top_instructions ||= [
+        :init,
+        *generate_top_instructions,
+        :end
+      ]
+    end
+
+    def subroutine_instructions
+      @subroutine_instructions ||=
+        subroutines.values.flat_map(&:body_instructions)
+    end
+
+    def generate_labels
+      count = 0
+      subroutines.values.map do |sub|
+        arr = [sub.label, top_instructions.count + count]
+        count += sub.body_instructions.count
+        arr
+      end.to_h
+    end
+
+    def deletables
+      @extant.reject { |k, _| @dsl.resources.key? k }
+    end
+
+    def updatables
+      @dsl.resources
+    end
+
+    def generate_subroutines
+      result = {}
+      # set up resources for deletion
+      deletables.each do |k, v|
+        desc = Tataru.const_get(v).new
+        rrep = Representations::ResourceRepresentation.new(k, desc, {})
+        sp = SubPlanner.new(rrep, :delete)
+        result.merge!(sp.subroutines)
+      end
+
+      # set up resources for updates or creates
+      updatables.each do |k, rrep|
+        action = @extant.key?(k) ? :update : :create
+        sp = SubPlanner.new(rrep, action)
+        result.merge!(sp.subroutines)
+      end
+      result
+    end
+
+    def generate_step_order(order, steps)
+      instructions = []
+      order.each do |level|
+        steps.each do |step|
+          instructions += level.map do |item|
+            subroutines["#{item}_#{step}"].call_instruction
+          end
+        end
+      end
+      instructions
+    end
+
+    def generate_top_instructions
+      order = Bunny::Tsort.tsort(@extant_dependencies.merge(@dsl.dep_graph))
+
+      generate_step_order(order, %i[start check]) +
+        generate_step_order(order.reverse, %i[commit finish])
+    end
+  end
+end

data/lib/tataru/create_subroutines.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Tataru
+  # create subroutines
+  module CreateSubroutines
+    def create_instructions
+      @rrep.check_required_fields!
+      [
+        *load_resource_instructions,
+        { key: :properties },
+        { value_rom: @rrep.name },
+        :create
+      ]
+    end
+
+    def check_create_instructions
+      [
+        *load_resource_instructions,
+        :check_create
+      ]
+    end
+
+    def commit_create_instructions
+      []
+    end
+
+    def finish_create_instructions
+      []
+    end
+  end
+end

data/lib/tataru/delete_subroutines.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Tataru
+  # delete subroutines
+  module DeleteSubroutines
+    def delete_instructions
+      return [] if desc.delete_at_end?
+
+      [
+        *load_resource_instructions,
+        :delete
+      ]
+    end
+
+    def check_delete_instructions
+      return [] if desc.delete_at_end?
+
+      [
+        *load_resource_instructions,
+        :check_delete
+      ]
+    end
+
+    def commit_delete_instructions
+      return [] unless desc.delete_at_end?
+
+      [
+        *load_resource_instructions,
+        :delete
+      ]
+    end
+
+    def finish_delete_instructions
+      return [] unless desc.delete_at_end?
+
+      [
+        *load_resource_instructions,
+        :check_delete
+      ]
+    end
+  end
+end

data/lib/tataru/flattener.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module Tataru
+  # flattens properties to make them digestable
+  class Flattener
+    def initialize(value)
+      @value = value
+      @result = {}
+    end
+
+    def flattened
+      flatten(@value, :top)
+      @result
+    end
+
+    def flatten(value, name)
+      type = value.class.name
+                  .sub(/^Tataru::Representations::/, '')
+                  .sub(/Representation$/, '')
+                  .downcase
+      method_name = :"flatten_#{type}"
+      raise "cannot flatten #{value.inspect}" unless respond_to?(method_name)
+
+      send(method_name, value, name)
+    end
+
+    def flatten_literal(value, name)
+      @result[name] = {
+        type: :literal,
+        value: value.value
+      }
+    end
+
+    def flatten_array(value, name)
+      refs = {}
+      value.value.each_with_index do |val, i|
+        key = :"#{name}_#{i}"
+        flatten(val, key)
+        refs[i] = key
+      end
+      @result[name] = {
+        type: :array,
+        references: refs
+      }
+    end
+
+    def flatten_hash(value, name)
+      refs = {}
+      value.value.each do |k, v|
+        key = :"#{name}_#{k}"
+        flatten(v, key)
+        refs[k] = key
+      end
+      @result[name] = {
+        type: :hash,
+        references: refs
+      }
+    end
+
+    def flatten_resource(value, name)
+      refs = {}
+      value.properties.each do |k, v|
+        key = :"#{name}_#{k}"
+        flatten(v, key)
+        refs[k] = key
+      end
+      @result[name] = {
+        type: :hash,
+        references: refs
+      }
+    end
+
+    def flatten_output(value, name)
+      @result[name] = {
+        type: :output,
+        resource: value.resource_name,
+        output: value.output_field_name
+      }
+    end
+  end
+end