rachinations 0.0.1

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

@@ -0,0 +1,11 @@
+require_relative '../../domain/resources/token'
+require_relative '../../domain/nodes/node'
+
+class ResourcelessNode < Node
+
+  # only for now.
+  def resource_count(&blk)
+    0
+  end
+
+end

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

@@ -0,0 +1,17 @@
+require_relative '../../domain/nodes/pool'
+# You can send anything to a Sink.
+# Think of it like a Blackhole for resources.
+
+class Sink < Pool
+
+
+  def take_resource!(type=nil, &expression)
+    # do nothing
+  end
+
+  def put_resource!(obj)
+    inv{obj.unlocked?}
+    # do nothing
+  end
+
+end

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

@@ -0,0 +1,161 @@
+require_relative '../../domain/nodes/pool'
+
+class Source < ResourcefulNode
+
+
+  def initialize(hsh={})
+
+    check_options!(hsh)
+    params = set_defaults(hsh)
+
+    @type = params[:type]
+    @mode = params[:mode]
+    @activation = params[:activation]
+    @name = params[:name]
+
+    super
+
+  end
+
+  alias_method :support?, :supports?
+
+  def typed?
+    !@type.nil?
+  end
+
+  def untyped?
+    !typed?
+  end
+
+  def to_s
+    "Source '#{@name}':  #{@resources.to_s}"
+  end
+
+  def put_resource!;
+  end
+
+  def take_resource!(type=nil)
+
+    if type.nil? && untyped?
+      res = Token.new
+      type_taken = nil
+    elsif !type.nil? && supports?(type)
+      res = type.new
+      type_taken = type
+    else
+      res = self.type.new
+      type_taken = self.type
+    end
+
+    @resources_removed[type_taken] += 1
+
+    fire_triggers!
+
+    res
+
+  end
+
+  def types
+    [@type]
+  end
+
+  def trigger!
+    if enabled?
+      if push? && any?
+
+        push_any!
+
+      elsif pull?
+
+        raise NotImplementedError('A pulling Source?')
+
+      end
+
+    end
+  end
+
+  def resources_added
+    0
+  end
+
+  def resources_removed(type=nil)
+
+    if type.nil?
+      @resources_removed[Token]
+    else
+      @resources_removed[type]
+    end
+
+  end
+
+  def resource_count(type=nil)
+    return 0
+  end
+
+  private
+
+  def remove_resource!(&expression)
+
+    #we'll need to change this if source starts accepting
+    # more than a single type
+    inv { types.size === 1 }
+
+    if type.nil?
+      res = Token.new
+    else
+      res = type.new
+    end
+
+    if (expression.call(res))
+      @resources_removed[res.type] += 1
+      res
+    else
+      raise RuntimeError.new("This Source cannot provide a resource matching given expression.")
+    end
+
+
+  end
+
+  attr_reader :type
+
+  private
+
+  def push_any!
+    outgoing_edges
+    .shuffle
+    .each do |edge|
+      begin
+        blk = edge.push_expression
+      rescue => ex
+        # Could not get a block for one Edge, but this is push_any so I'll go ahead.
+        next
+      end
+
+      edge.label.times do
+        begin
+          res = remove_resource!(&blk)
+        rescue => ex
+          # Failed to remove this resource. Let's try another Edge, perhaps?
+          break
+        end
+
+        edge.push!(res)
+
+      end
+
+    end
+  end
+
+  def options
+    [:type, :mode, :activation, :diagram, :conditions, name: :required]
+  end
+
+  def defaults
+    {
+        type: nil,
+        mode: :push_any,
+        activation: :automatic
+    }
+  end
+
+end

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

@@ -0,0 +1,6 @@
+require_relative '../../domain/nodes/node'
+require_relative '../../domain/nodes/resourceless_node'
+
+class Trader < ResourcelessNode
+
+end

data/lib/rachinations/domain/resource_bag.rb

@@ -0,0 +1,131 @@
+require 'active_support/all'
+require_relative '../domain/modules/common/invariant'
+
+
+class ResourceBag
+  include Invariant
+
+  def initialize
+    @store = Array.new
+  end
+
+  def initialize_copy(orig)
+    super
+    @store=@store.map { |el| el.clone }
+
+  end
+
+  def add!(obj)
+    @store.push(obj)
+  end
+
+  #retrieve
+  def get(klass)
+
+    if count(klass) === 0
+      raise NoElementsOfGivenTypeError, "No elements of class #{klass} found."
+    end
+
+    obj = store.select { |el| el.is_a?(klass) }.sample
+
+    remove_element!(obj)
+    obj
+
+  end
+
+  def count(klass)
+
+    inv { klass.is_a?(Class) }
+
+    store.select { |el| el.is_a?(klass) }.length
+
+  end
+
+  def count_where(&blk)
+
+    raise ArgumentError, 'Please supply a block containing the condition.' unless block_given?
+
+    amount = 0
+
+    store.each { |e|
+      amount += 1 if yield e
+    }
+
+    amount
+
+  end
+
+  def each_where
+    raise ArgumentError, 'Please supply a block containing the condition to apply for each resource.' unless block_given?
+
+    store.each { |r| yield r }
+
+  end
+
+  def get_where &condition
+    raise ArgumentError, 'Please supply a block containing the condition to apply..' unless block_given?
+    raise NoElementsMatchingConditionError, "No elements found matching given condition." unless theres_at_least_one_where &condition
+
+    obj = store.select{|r| r.unlocked? }.select { |r| (yield r) }.sample
+
+    remove_element!(obj)
+    obj
+
+  end
+
+  # created so that I don't have to call count everytime just to see whether there's at least one element matching said condition
+  def theres_at_least_one_where
+
+    raise ArgumentError, 'Please supply a block containing the condition.' unless block_given?
+
+    store.each do |e|
+      if e.unlocked? && (yield e)
+        return true
+      end
+    end
+
+    false
+
+  end
+
+  def to_s
+    out = ''
+
+    classes = store.map { |el| el.class }.uniq
+
+    classes.each do |klass|
+
+      name = if klass.name.nil?
+               'Anonymous Klass'
+             else
+               klass.name
+             end
+
+      out += "\n"+'    '+ name + ' -> '+ count(klass).to_s+"\n\n"
+    end
+
+    if classes.empty?
+      "\n    Empty\n\n"
+    else
+      out
+    end
+
+
+  end
+
+  private
+
+
+  def store
+    @store
+  end
+
+  def remove_element!(obj)
+
+    if @store.delete(obj).nil?
+      raise NoElementsOfGivenTypeError
+    end
+
+  end
+
+end

data/lib/rachinations/domain/resources/token.rb

@@ -0,0 +1,51 @@
+class Token
+
+  
+  def initialize
+    @lock= false
+  end
+
+  def lock!
+    if locked?
+      raise RuntimeError, 'Tried to lock a locked Token.'
+    else
+      @lock = true
+    end
+    self
+  end
+
+  def type
+    self.class
+  end
+
+  def is_type?(type)
+    self.type.eql? type
+  end
+
+  def unlock!
+    if unlocked?
+      raise RuntimeError, 'Tried to unlock an unlocked Token.'
+    else
+      @lock = false
+    end
+    self
+  end
+
+  def locked?
+    @lock == true
+  end
+
+  def unlocked?
+    @lock == false
+  end
+
+  #hooks which can be overridden in child classes
+  def reached_node(node); end
+
+  def left_node(node); end
+
+  def reached_edge(edge); end
+
+  def left_edge(edge); end
+
+end

data/lib/rachinations/domain/strategies/strategy.rb

@@ -0,0 +1,5 @@
+class Strategy
+
+  #subclasses Strategy to define and encapsulate specific algorithm and policies to use in your application.
+
+end

data/lib/rachinations/domain/strategies/valid_types.rb

@@ -0,0 +1,69 @@
+require_relative 'strategy'
+
+class ValidTypes < Strategy
+
+  # @note from_node is only included in the constructor's argument
+  #  list to check whether it is enabled, but it isn't used anywhere lese.
+  def initialize(from_node, edge, to_node)
+    @from_node = from_node
+    @edge = edge
+    @to_node = to_node
+  end
+
+  # Returns the expression block which can used by from_node in order
+  # to select a resource that is supported by both the edge and the node
+  # to which the resource will be transferred.
+  #
+  # @return [Proc] the expression block.
+  def condition
+
+    return match_none_expression if [@from_node, @edge, @to_node].any? {|el| el.disabled? }
+
+    edge_types = @edge.types
+    to_node_types = @to_node.types
+
+    if edge_types.empty? && to_node_types.empty?
+      match_all_expression
+    else
+      if edge_types.empty? && (not to_node_types.empty?)
+        Proc.new { |res| to_node_types.include?(res.type) }
+      elsif to_node_types.empty? && (not edge_types.empty?)
+        Proc.new { |res| edge_types.include?(res.type) }
+      else
+        Proc.new { |res| edge_types.include?(res.type) && node_types.include?(res.type) }
+      end
+    end
+
+  end
+
+  # Returns an expression block which can be used to decide whether a given
+  # resource is supported both by the edge and by to_node.
+  #
+  # @return [Proc] the expression block
+  def push_condition
+    condition
+  end
+
+  # Returns an expression block which can be used to decide whether a given
+  # resource is supported both by the edge and by from_node.
+  #
+  # @return [Proc] the expression block
+  def pull_condition
+    condition
+  end
+
+  private
+
+  def unsatisfiable_expression
+    Proc.new { true == false }
+  end
+
+  def any_satisfiable_expression
+    Proc.new { true == true }
+  end
+
+  alias_method :match_all_expression, :any_satisfiable_expression
+  alias_method :match_none_expression, :unsatisfiable_expression
+
+
+end