tataru 0.1.0 → 0.2.0

data/lib/tataru/planner.rb

@@ -1,93 +0,0 @@
-# frozen_string_literal: true
-
-module Tataru
-  module Rage
-    # not valid
-    class InvalidRequirement < StandardError; end
-  end
-
-
-  # A plan
-  class Planner
-    def initialize(current_state, requirement)
-      @current_state = current_state
-      @requirement = requirement
-      @actions = {}
-
-      raise Rage::InvalidRequirement unless requirement.valid?
-    end
-
-    def order
-      Bunny::Tsort.tsort(@requirement.dep_tree)
-    end
-
-    def delete_instruction_for(id, pref)
-      Instruction.new(:"#{pref}_delete", id, @current_state[id], @requirement)
-    end
-
-    def generate_delete_instruction_for(id, pref)
-      return if @current_state[id].nil?
-      return unless action(id) == :replace
-
-      delete_instruction_for(id, pref)
-    end
-
-    def generate_instruction_for(id, pref)
-      if @current_state[id].nil?
-        Instruction.new(:"#{pref}_create", id, end_state[id], @requirement)
-      elsif action(id) == :replace
-        Instruction.new(:"#{pref}_create", id, end_state[id], @requirement)
-      elsif action(id) == :update
-        Instruction.new(:"#{pref}_update", id, end_state[id], @requirement)
-      end
-    end
-
-    def generate_removal_instructions
-      remove_actions = []
-      @current_state.id_list.keys.each do |id|
-        next if @requirement.exist? id
-
-        remove_actions << delete_instruction_for(id, :begin)
-      end
-      remove_actions
-    end
-
-    def generate_delete_instructions
-      delete_actions = []
-      order.reverse.each do |step|
-        %i[begin wait].each do |substep|
-          step.each do |id|
-            delete_action = generate_delete_instruction_for(id, substep)
-            delete_actions << delete_action unless delete_action.nil?
-          end
-        end
-      end
-      delete_actions + generate_removal_instructions
-    end
-
-    def generate_instructions
-      instr = []
-      order.each do |step|
-        %i[begin wait].each do |substep|
-          step.each do |id|
-            instruction = generate_instruction_for(id, substep)
-            instr << instruction unless instruction.nil?
-          end
-        end
-      end
-      instr + generate_delete_instructions
-    end
-
-    def instructions
-      @instructions ||= generate_instructions
-    end
-
-    def action(id)
-      @actions[id] ||= @requirement.action(id, @current_state[id])
-    end
-
-    def end_state
-      @requirement.end_state
-    end
-  end
-end

data/lib/tataru/requirements.rb

@@ -1,67 +0,0 @@
-# frozen_string_literal: true
-
-module Tataru
-  # Requirements list
-  class Requirements
-    attr_reader :resource_finder, :errors
-
-    def initialize(resource_finder = DefaultResourceFinder.new, &block)
-      dsl = RequirementsDSL.new(resource_finder)
-      dsl.instance_exec(&block)
-      @errors = dsl.errors
-      @reqs = dsl.resource_list
-      @resource_finder = resource_finder
-    end
-
-    def dep_tree
-      @reqs.map { |k, v| [k, v[:dependencies]] }.to_h
-    end
-
-    def end_state
-      state = State.new
-      @reqs.each do |id, info|
-        info[:state].each do |state_name, state_value|
-          state.putstate(id, state_name, state_value)
-        end
-      end
-      state
-    end
-
-    def exist?(id)
-      @reqs.key? id
-    end
-
-    def type(id)
-      @reqs[id][:type]
-    end
-
-    def valid?
-      errors.length.zero?
-    end
-
-    def compare(id, current_state)
-      rclass = @resource_finder.resource_named(type(id))
-      resdef = rclass.new
-      changed = false
-      replace = false
-
-      current_state.each do |state_name, current_value|
-        next if current_value == @reqs[id][:state][state_name]
-
-        changed = true
-        replace ||= resdef.send(:"#{state_name}_change_action") == :replace
-      end
-
-      [changed, replace]
-    end
-
-    def action(id, current_state)
-      changed, replace = compare(id, current_state)
-
-      return :nothing unless changed
-      return :update unless replace
-
-      :replace
-    end
-  end
-end

data/lib/tataru/requirements_dsl.rb

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-
-module Tataru
-  # Requirements DSL
-  class RequirementsDSL
-    attr_reader :resource_list
-
-    def initialize(resource_finder)
-      @resource_finder = resource_finder
-      @resource_list = {}
-    end
-
-    def respond_to_missing?
-      true
-    end
-
-    def method_missing(type, name, &block)
-      rclass = @resource_finder.resource_named(type)
-      res = ResourceDSL.new(rclass.new)
-      res.instance_exec(&block) if block
-      @resource_list[name] = {
-        type: type, dependencies: res.dependencies,
-        state: res.fields, errors: res.errors
-      }
-    rescue NameError
-      super
-    end
-
-    def errors
-      @resource_list.flat_map { |_, v| v[:errors] }
-    end
-  end
-end

data/lib/tataru/resource.rb

@@ -1,52 +0,0 @@
-# frozen_string_literal: true
-
-module Tataru
-  # base resource class
-  class Resource
-    class << self
-      def state(state_name, change_behaviour)
-        define_method "#{state_name}_change_action" do
-          change_behaviour
-        end
-
-        define_method "_state_#{state_name}" do
-          state_name
-        end
-      end
-
-      def output(output_name)
-        define_method "_output_#{output_name}" do
-          output_name
-        end
-
-        define_method(output_name) {}
-      end
-    end
-
-    def states
-      list_props(:state)
-    end
-
-    def outputs
-      list_props(:output)
-    end
-
-    %i[
-      begin_create
-      begin_update
-      begin_delete
-      create_complete?
-      update_complete?
-      delete_complete?
-    ].each do |thing|
-      define_method(thing) { |_state| }
-    end
-
-    private
-
-    def list_props(prop_type)
-      methods.select { |x| x.to_s.start_with? "_#{prop_type}_" }
-             .map { |x| x.to_s.sub("_#{prop_type}_", '').to_sym }
-    end
-  end
-end

data/lib/tataru/state.rb

@@ -1,64 +0,0 @@
-# frozen_string_literal: true
-
-module Tataru
-  # The state of the environment
-  class State
-    def initialize(objstate = {})
-      @current_ids = objstate[:current_ids] || {}
-      @replacer_ids = objstate[:replacer_ids] || {}
-      @waiting_ids = objstate[:waiting_ids] || {}
-    end
-
-    def putstate(id, state, value, replacer: false)
-      ids = id_list(replacer)
-      ids[id] = {} unless ids.key? id
-      ids[id][state] = value
-    end
-
-    def getstate(id, state, replacer: false)
-      ids = id_list(replacer)
-      return unless ids.key? id
-
-      ids[id][state]
-    end
-
-    def id_list(replacer = false)
-      return @replacer_ids if replacer
-
-      @current_ids
-    end
-
-    def replace(id)
-      @current_ids[id] = @replacer_ids[id]
-      @replacer_ids.delete(id)
-    end
-
-    def delete_list
-      @replacer_ids.keys.select { |x| @current_ids.key? x }
-    end
-
-    def [](id)
-      @current_ids[id].clone
-    end
-
-    def waiting_on(id, what)
-      @waiting_ids[id] = what
-    end
-
-    def no_longer_waiting(id)
-      @waiting_ids.delete(id)
-    end
-
-    def waiting_list
-      @waiting_ids.clone
-    end
-
-    def to_h
-      {
-        current_ids: @current_ids,
-        replacer_ids: @replacer_ids,
-        waiting_ids: @waiting_ids
-      }
-    end
-  end
-end