rachinations 0.0.1

data/lib/rachinations/domain/edge_collection.rb

@@ -0,0 +1,12 @@
+require 'forwardable'
+
+class EdgeCollection
+  extend Forwardable
+
+  def_delegators :@edges, :[], :<<, :each, :push, :map, :select, :detect, :reduce
+
+  def initialize
+    @edges = []
+  end
+
+end

data/lib/rachinations/domain/edges/edge.rb

@@ -0,0 +1,159 @@
+require_relative '../strategies/valid_types'
+require_relative '../../domain/exceptions/no_elements_found'
+
+class Edge
+
+  attr_reader :from, :to, :name, :label, :types
+
+
+  def initialize(hsh)
+
+    @name = hsh.fetch(:name)
+
+    @from = hsh.fetch(:from)
+
+    @to = hsh.fetch(:to)
+
+    #setting default values if needed.
+    hsh = defaults.merge hsh
+
+    @label = hsh.fetch(:label)
+    @types = hsh.fetch(:types)
+
+  end
+
+  # Simulates a ping!, but no resources get actually
+  # moved.
+  #
+  # @param [Boolean] require_all whether to require that the maximum
+  #  number of Resources allowed (as per this Edge's label) be
+  #  able to pass in order to return true.
+  #
+  # @return [Boolean] true in case a ping! on this Edge
+  #  would return true. False otherwise.
+  def test_ping?(require_all=false)
+    return false if from.disabled? || to.disabled?
+
+    condition = strategy.condition
+
+    available_resources = from.resource_count(&condition)
+
+    if available_resources == 0
+      false
+    elsif available_resources >= label
+      true
+    elsif available_resources < label && require_all
+      false
+    else
+      # only some resources are able to pass but it's not require_all
+      true
+    end
+
+  end
+
+  # the code is the code but sometimes it helps to specify what action
+  # we are talking about so as to make code more understandable
+  alias_method :test_pull?, :test_ping?
+  alias_method :test_push?, :test_ping?
+
+  def supports?(type)
+    types.empty? || types.include?(type)
+  end
+
+  alias_method :support?, :supports?
+
+  def enabled?
+    true
+  end
+
+  def disabled?
+    not enabled?
+  end
+
+  def untyped?
+    types.empty?
+  end
+
+  def typed?
+    not untyped?
+  end
+
+  def from?(obj)
+    from.equal?(obj)
+  end
+
+  def to?(obj)
+    to.equal?(obj)
+  end
+
+  # Returns a block which will be later used by the calling node to search
+  # for a suitable resource.
+  #
+  # @return [Proc] a condition block
+  def push_expression
+    strategy.push_condition
+  end
+
+  # Returns a block which will be later used as a parameter
+  # to method pull!.
+  #
+  # @return [Proc] a condition block
+  def pull_expression
+    strategy.pull_condition
+  end
+
+  # Takes a resource and puts it into the node at the other
+  # end of this Edge.
+  #
+  # @raise [RuntimeError] in case the receiving node or this Edge
+  #  won't accept the resource sent.
+  # @param res the resource to send.
+  def push!(res)
+    raise RuntimeError.new "This Edge does not support type: #{res.type}" unless supports?(res.type)
+
+    begin
+      to.put_resource!(res,self)
+    rescue => e
+      # just to make it clear that it bubbles
+      raise RuntimeError.new(e.message+" => "+'Push failed')
+    end
+  end
+
+  # Tries to take a resource matching given block
+  # from the node at the other end.
+  #
+  # @param [Proc] blk  block that will define what resource the other node
+  #  should send.
+  # @raise [RuntimeError] in case the other node could provide no resources
+  #  that satisfy this condition block.
+  # @return a resource that satisfies the given block.
+  def pull!(&blk)
+    begin
+      res=from.take_resource!(&blk)
+    rescue => e
+      # just to make it clear that it bubbles
+      raise RuntimeError.new("Pull failed")
+    else
+      res
+    end
+
+  end
+
+  def to_s
+    "Edge '#{@name}', from '#{from.name}' to '#{to.name}'"
+  end
+
+  private
+
+  def strategy
+    ValidTypes.new(from, self, to)
+  end
+
+  def defaults
+    {
+        :label => 1,
+        :types => []
+    }
+  end
+
+end

data/lib/rachinations/domain/edges/random_edge.rb

@@ -0,0 +1,4 @@
+require_relative '../../domain/edges/edge'
+
+class RandomEdge < Edge
+end

data/lib/rachinations/domain/exceptions/bad_options.rb

@@ -0,0 +1,3 @@
+class BadOptions < ArgumentError
+
+end

data/lib/rachinations/domain/exceptions/no_elements_found.rb

@@ -0,0 +1,2 @@
+class NoElementsFound < RuntimeError
+end

data/lib/rachinations/domain/exceptions/no_elements_matching_condition_error.rb

@@ -0,0 +1,2 @@
+class NoElementsMatchingConditionError < RuntimeError
+end

data/lib/rachinations/domain/exceptions/no_elements_of_given_type.rb

@@ -0,0 +1,3 @@
+class NoElementsOfGivenTypeError < RuntimeError
+
+end

data/lib/rachinations/domain/exceptions/unsupported_type_error.rb

@@ -0,0 +1,2 @@
+class UnsupportedTypeError < RuntimeError
+end

data/lib/rachinations/domain/modules/common/hash_init.rb

@@ -0,0 +1,88 @@
+#use this for classes you want to be able to instantiate
+#using a hashful of parameters
+module HashInit
+
+  class ::Array
+
+    def include_option? opt
+
+      each do |el|
+        if el == opt
+          return true
+        elsif el.is_a?(Hash) && el.has_key?(opt)
+          return true
+        end
+      end
+
+      false
+    end
+
+  end
+
+  def initialize(hsh={})
+
+    raise BadOptions.new 'This class requires a hash as parameter to its constructor.'  if !hsh.is_a?(Hash)
+
+    check_options!(hsh)
+    hsh=set_defaults(hsh)
+  end
+
+  def check_options!(hsh)
+
+    #watch out for unknown options - might be typos!
+    hsh.each_pair do |key, value|
+
+      if !options.include_option?(key) && aliases_for(key).none?{|ali| options.include_option?(ali) }
+        raise BadOptions.new "Unknown option in parameter hash: :#{key} "
+      end
+    end
+
+    #make sure all required ones are there
+
+    options.each do |el|
+      if el.is_a? Hash
+
+        #we know for sure it's got only one key and one value
+        k = el.keys[0]
+        v = el.values[0]
+
+        if v == :required
+
+          if !hsh.has_key?(k) && hsh.keys.all?{|opt| aliases_for(opt).none?{|ali| ali == k } }
+            raise BadOptions.new "Required option #{k} was not found in parameter hash."
+          end
+        end
+
+      end
+    end
+
+  end
+
+  def aliases_for(opt)
+    aliases.select{|k,v| k == opt }.values
+  end
+
+  def set_defaults(hsh)
+    #in case the user hasn't passed full parameters to the constructor
+    defaults.merge hsh
+  end
+
+  # This method should be implemented by each client to indicate the options accepted.
+  #@return [Array] An array of accepted options.
+  #@example Many client Classes specify a :name option:
+  #  def options
+  #    [:name]
+  #  end
+  def options
+    []
+  end
+
+  def defaults
+    {}
+  end
+
+  def aliases
+    {}
+  end
+
+end

data/lib/rachinations/domain/modules/common/invariant.rb

@@ -0,0 +1,17 @@
+module Invariant
+
+  #used to insert assertions into code
+  #remember that assertions should not be used to control program flow!!! assert things that should ALWAYS be false.
+
+  class AssertionError < RuntimeError
+
+  end
+
+
+
+  def invariant &block
+    raise AssertionError unless yield
+  end
+
+  alias_method :inv, :invariant
+end

data/lib/rachinations/domain/modules/diagrams/verbose.rb

@@ -0,0 +1,30 @@
+module Verbose
+
+
+  def before_run
+    print "\033[1;32m===== INITIAL STATE =====\e[00m\n\n"
+
+    puts self
+  end
+
+  def after_run
+    print "\033[1;32m====== FINAL STATE ======\e[00m\n\n"
+
+    puts self
+
+    print "\033[1;31m========== END ==========\e[00m\n\n"
+  end
+
+  def before_round(round_no)
+    print "======= ROUND #{round_no} =======\n\n"
+  end
+
+  def after_round (round_no)
+    puts self
+  end
+
+  def sanity_check_message
+    print "\033[1;31m= SAFEGUARD CONDITION REACHED - ABORTING EXECUTION =\e[00m\n\n"
+  end
+
+end

data/lib/rachinations/domain/node_collection.rb

@@ -0,0 +1,30 @@
+require 'forwardable'
+
+class NodeCollection
+  extend Forwardable
+
+  def_delegators :@array, :[], :<<, :each, :push, :map, :select, :detect , :reduce, :shuffle, :sample
+
+
+  def initialize(init_array=nil)
+
+    if init_array.nil?
+      @array = []
+    else
+      @array = init_array
+    end
+  end
+
+  def passive
+    @array.select{|el| el.passive? }
+  end
+
+  def automatic
+    @array.select{|el| el.automatic? }
+  end
+
+  def detect_by_name(name)
+    @array.detect{|el| el.name === name }
+  end
+
+end

data/lib/rachinations/domain/nodes/converter.rb

@@ -0,0 +1,276 @@
+require_relative '../../domain/nodes/node'
+require_relative '../../domain/nodes/resourceless_node'
+
+class Converter < ResourcefulNode
+
+# VEJA O DIAGRAMA BEHAVIOR CONVERTER, inclusive com o equivalente dele
+
+# um converter, ao ser ativado, deve tirar de um lugar e passar para outro
+# nada fica guardado em um converter no sentido do pool, porém algumas coisas podem ficar
+# temporariamente anotadas nele porque não foi completado ainda o & ou todos os recursos necessários
+
+# um converter pode ser ativado de 3 maneiras
+# por si mesmo
+# quando um no que empurra empurra algo para ele
+# quando um no que puxa puxa dele
+
+# O tipo do conversor define o tipo de saida padrao
+# porem o tipo do edge tem vantagem na definicao da saida
+# O exemplo com 3 saidas mostra isso
+
+  def initialize(hsh={})
+    check_options!(hsh)
+    hsh = set_defaults(hsh)
+    @name = hsh.fetch(:name)
+    @mode = hsh.fetch(:mode)
+    @types = hsh.fetch(:types)
+    @activation = hsh.fetch(:activation)
+
+    # each edge may have contributed with some resources at any given time
+    @resources_contributed = init_resources
+
+  end
+
+  # Activates this Converter. It will try to pull from
+  #  incoming nodes and, if successful, will push into
+  #  outgoing nodes.
+  def trigger!
+
+    if all?
+
+      if incoming_edges.all? { |edge| edge.test_pull?(true) } && outgoing_edges.all? { |edge| edge.test_push?(true) }
+        pull_all!
+        push_all!
+      else
+        # does not trigger
+      end
+
+    elsif any?
+
+      pull_any!
+
+      if in_conditions_met?
+        if outgoing_edges.all? { |edge| edge.test_push?(true) }
+          push_all!
+          pop_stored_resources!
+        end # converters are always push_all
+      end # conditions weren't met this turn
+
+    else
+      raise ArgumentError.new "Unsupported mode :#{mode}"
+    end
+
+  end
+
+  # Puts a Resource into a Converter. The Edge may be used
+  #  as index for internal states and the Resource may be
+  #  used in case not all edge conditions have been met
+  #  (only applicable when in pull_any mode).
+  #
+  def put_resource!(res, edge=nil)
+    inv { !edge.nil? }
+    if all?
+      if incoming_edges.all? { |e| e.test_push? }
+        push_all!
+      end
+    elsif any?
+      add_to_contributed_resources!(res, edge)
+      if in_conditions_met?
+        push_all!
+      end
+    end
+
+  end
+
+  # An override for the original method. The reason for this is
+  # that, when an Edge is attached to a Converter after it's been
+  # created, a key for it (frozen) needs to be created.
+  #
+  # @param [Edge] edge
+  def attach_edge!(edge)
+    #TODO use argument (edge) on the call to super and make sure tests still pass
+    # that way it's clearer that it is being passed on to super
+    super
+    resources_contributed.store(edge, Fifo.new)
+    self
+  end
+
+  def take_resource!(type=nil, &blk)
+    if incoming_edges.shuffle.all? { |edge| edge.test_pull? }
+      pull_all!
+    end
+  end
+
+
+  def resource_count(type=nil,&block)
+    return Float::INFINITY
+  end
+
+  def to_s
+    "Converter '#{@name}'"
+  end
+
+  private
+
+  # This method is used to test whether a Converter
+  # has had the conditions for incoming edges met.
+  #
+  # @return [Boolean] true if conditions for pull_any
+  #  have all been met, false otherwise
+  def in_conditions_met?
+
+    edges = incoming_edges
+
+    incoming_edges
+    .all? { |edge| resources_contributed.keys.include?(edge) && resources_contributed.fetch(edge).length >= edge.label }
+  end
+
+  # This removes from the internal store just enough
+  # resources to accomplish one push_all (only applicable when in pull_any mode)
+  def pop_stored_resources!
+    #TODO
+  end
+
+
+  attr_accessor :resources_contributed
+
+  def pull_any!
+    incoming_edges
+    .shuffle
+    .each do |edge|
+      begin
+        blk = edge.pull_expression
+      rescue RuntimeError => ex
+        # Could not get a block for one Edge, but this is pull_any so I'll go ahead.
+        next #other edges might still be able to serve me.
+      end
+
+      edge.label.times do
+        begin
+          res = edge.pull!(&blk)
+        rescue RuntimeError => ex
+          # Let's try another Edge, perhaps?
+          break
+        end
+
+        # right here we would add the returned resource to the store,
+        # but with converters we dont store the resources;  we just
+        # record that this edge has contributed one resource:
+        add_to_contributed_resources!(res, edge)
+
+      end
+
+    end
+
+  end
+
+  def pull_all!
+
+    incoming_edges
+    .shuffle
+    .each do |edge|
+      begin
+        blk = edge.pull_expression
+      rescue RuntimeError => ex
+        raise RuntimeError.new "One edge failed to provide an expression; the whole operation failed."
+      end
+
+      edge.label.times do
+        begin
+          res = edge.pull!(&blk)
+          res=nil # we do not store the results
+        rescue RuntimeError => ex
+          raise RuntimeError.new "One edge failed to pull; the whole operation failed."
+        end
+
+      end
+
+    end
+
+  end
+
+  def push_all!
+    outgoing_edges
+    .shuffle
+    .each do |edge|
+      begin
+        exp = edge.push_expression
+      rescue RuntimeError => ex
+        raise RuntimeError.new "One edge failed to provide an expression; the whole operation failed."
+      end
+
+      edge.label.times do
+
+        begin
+          res = make_resource(&exp)
+        rescue RuntimeError => ex
+          raise RuntimeError.new "This Converter cannot provide any suitable Resource."
+        end
+
+        begin
+          edge.push!(res)
+        rescue RuntimeError => e
+          raise RuntimeError.new e.message+" SO "+"One push over an edge failed; the whole operation failed."
+        end
+
+      end
+
+    end
+
+
+  end
+
+  def push_any!
+    raise NotImplementedError.new "Converters cannot push_any. Only push_all."
+  end
+
+  # Try to produce a Resource matching given condition.
+  #
+  # @return [Token] a token resource or any of its subtypes
+  # @raise [RuntimeError] in case this Converter cannot produce any
+  #  Resource that matches the condition.
+  def make_resource(&condition)
+
+    if untyped?
+      res = Token.new
+      if condition.match_resource?(res)
+        res
+      else
+        raise RuntimeError.new "Failed to make Resource matching given conditions."
+      end
+    else
+      types.shuffle.each do |type|
+        res = type.new
+        if condition.match_resource?(res)
+          return res
+        end
+      end
+      raise RuntimeError.new "Failed to make Resource matching given conditions."
+    end
+
+  end
+
+  # A Converter may receive its needed resources across turns
+  # so there must be a way to keep count of which edges have already
+  # 'given their contribution' to this Converter.
+  def add_to_contributed_resources!(resource, edge)
+    resources_contributed.fetch(edge).put!(resource)
+  end
+
+  def init_resources
+    edges.reduce(Hash.new) { |hash, edge| hash.store(edge.object_id, Fifo.new) }
+  end
+
+  def options
+    [{name: :required}, :diagram, :mode, :activation, :types]
+  end
+
+  def defaults
+    {
+        mode: :pull_any,
+        activation: :passive,
+        types: []
+    }
+  end
+
+end